téléchargement hubot natural - téléchargement du code source hubot natural

Hubot Naturel

ChatBot en langage naturel

Hubot est l'un des frameworks de création de robots les plus connus sur le Web, car github facilite sa création. Si vous pouvez définir vos commandes dans un paramètre RegExp, vous pouvez essentiellement faire n'importe quoi avec Hubot. C'est une grande contribution à la culture ChatOps.

Inspirés par cela, nous voulions offrir la même simplicité à notre communauté pour développer des chatbots capables de réellement traiter le langage naturel et d'exécuter des tâches, aussi simplement que de créer des robots orientés RegExp.

Nous avons donc trouvé un projet vraiment charmant à partir duquel lancer, le Heartbot de Digital Ocean, un coup d'amour pour votre client de chat préféré =)

Basé sur Heartbot, nous avons introduit la puissance du NLP de l'équipe NaturalNode, une collection impressionnante de bibliothèques de traitement du langage naturel conçues pour être utilisées dans NodeJS.

Et voilà, la magie opère...

Bienvenue dans HubotNatural , un nouveau framework de chatbot passionnant basé sur les bibliothèques Hubot et NaturalNode, avec une architecture simple et extensible conçue par l'équipe HeartBot de Digital Ocean, réalisée avec amour et soin par l'équipe Rocket.Chat.

Nous espérons que vous apprécierez le projet et que vous trouverez du temps pour contribuer.

Comment ça marche

HubotNatural est conçu pour être facile à entraîner et à étendre. Donc, ce que vous devez comprendre, en gros, c'est qu'il dispose d'un corpus YAML, dans lequel vous pouvez concevoir vos interactions avec le chatbot en utilisant uniquement la notation YAML.

Toutes les interactions YAML conçues dans le corpus peuvent avoir leurs propres paramètres, qui seront traités par une classe d'événements.

Les classes événementielles donnent la possibilité d'étendre HubotNatural. En écrivant vos propres classes d'événements, vous pouvez donner à votre chatbot les compétences nécessaires pour interagir avec tous les services dont vous avez besoin.

Corpus YAML

Le fichier YAML est chargé dans scripts/index.js , analysé et transmis au chatbot bind, qui se trouvera dans scripts/bot/index.js , le cortex du bot, où tous les flux d'informations et tous les contrôles sont programmés.

Le corpus YAML se trouve dans training_data/corpus.yml et sa structure de base ressemble à ceci :

 trust : .85
interactions :
  - name : salutation
    expect :
      - hi there
      - hello everyone
      - what's up bot
      - good morning
    answer :
      - - Hello there $user, how are you?
        - Glad to be here...
      - Hey there, nice to see you!
    event : respond

Ce que signifie cette syntaxe :

trust : le niveau minimum de certitude qui doit être renvoyé par le classificateur pour exécuter cette interaction. La valeur est de 0 à 1 (0 % à 100 %). Si un classificateur renvoie une valeur de certitude inférieure à trust , les robots répondent avec un nœud d'interaction d'erreur.
interactions : Un vecteur avec de nombreux nœuds d'interaction qui seront analysés. Chaque interaction conçue pour votre chatbot doit se faire sous une structure d'objet interaction.node.
name : c'est le nom unique de l'interaction par lequel il sera identifié. Ne créez pas plus d’une interaction avec le même attribut node.name .
expect : Ce sont les phrases qui seront données aux robots en formation. Il peut s'agir de chaînes ou de vecteurs de mots-clés, comme ['consume','use'] .
answer : les messages qui seront envoyés à l'utilisateur, si les classificateurs sont classés au-dessus du niveau de confiance. Le node.message sera analysé et envoyé par classe d'événement. Afin d'utiliser des chaînes multilignes dans votre YAML, vous devez suivre la syntaxe des chaînes multilignes YAML. Vous pouvez spécifier des variables dans le message. Par défaut, HubotNatural est livré avec les variables $user , $bot et $room .
event : est le nom de la classe CoffeeScript ou JavaScript à l'intérieur scripts/events , sans l'extension de fichier.

Cours de café événementiels

Des classes d'événements peuvent être écrites pour étendre les compétences du chatbot. Ils reçoivent l'objet d'interaction et analysent le message, comme ceci :

 class respond
  constructor : (@interaction) ->
  process : (msg) =>
    sendMessages(stringElseRandomKey(@interaction.answer), msg)

module.exports = respond

Son constructeur de base est le nœud @interaction afin que vous puissiez avoir accès à tous les attributs d'une interaction en utilisant simplement @interaction.attribute . Ici, vous pouvez analyser des textes, appeler des API, lire des fichiers, accéder à des bases de données et tout ce dont vous avez besoin.
Vous souhaiterez peut-être utiliser la fonction stringElseRandomKey pour obtenir un élément aléatoire d'une liste, si son paramètre est une liste, et utiliser la fonction sendMessages pour envoyer des messages à un utilisateur.

Classificateur de régression logistique

La bibliothèque NaturalNode est livrée avec deux types de classificateurs, le classificateur Naive Bayes connu sous le nom de fonctions BayesClassifier et LogisticRegressionClassifier . Par défaut, HubotNatural utilise LogisticRegressionClassifier . Nos tests ont simplement donné de meilleurs résultats.

PorterStemmer

Il existe également plusieurs types de stemmer. Vous devez définir le stemmer pour définir votre langue. Par défaut, nous utilisons PorterStemmerPt pour le portugais, mais vous pouvez trouver des stemmers anglais, russes, italiens, français, espagnols et autres dans les bibliothèques NaturalNode, ou même écrire les vôtres à partir de ceux-ci.

Vérifiez simplement à l'intérieur node_modules/natural/lib/natural/stemmers/ .

Pour changer la langue des stemmers, définissez simplement la variable d'environnement HUBOT_LANG sur pt , en , es et toute autre terminaison de langue correspondant à un fichier stemmer dans le répertoire ci-dessus.

Déployer avec Docker

Nous avons un Dockerfile qui crée une image légère basée sur Linux Alpine avec tout le contenu du référentiel afin que vous puissiez télécharger cette image dans un registre Docker et déployer votre chatbot à partir de là. Il se trouve dans le dossier docker .

Vous pouvez également utiliser le fichier docker-compose.yml pour charger une instance locale des services Rocket.Chat, MongoDB et HubotNatural, où vous pouvez modifier les paramètres si vous le devez.

Le fichier docker-compose ressemble à ceci :

 version : ' 2 '

services :
  rocketchat :
    image : rocketchat/rocket.chat:latest
    restart : unless-stopped
    volumes :
      - ./uploads:/app/uploads
    environment :
      - PORT=3000
      - ROOT_URL=http://localhost:3000
      - MONGO_URL=mongodb://mongo:27017/rocketchat
      - MONGO_OPLOG_URL=mongodb://mongo:27017/local
      - MAIL_URL=smtp://smtp.email
#       - HTTP_PROXY=http://proxy.domain.com
#       - HTTPS_PROXY=http://proxy.domain.com
    depends_on :
      - mongo
    ports :
      - 3000:3000

  mongo :
    image : mongo:3.2
    restart : unless-stopped
    volumes :
     - ./data/db:/data/db
     # - ./data/dump:/dump
    command : mongod --smallfiles --oplogSize 128 --replSet rs0

  mongo-init-replica :
    image : mongo:3.2
    command : ' mongo mongo/rocketchat --eval "rs.initiate({ _id: '' rs0 '' , members: [ { _id: 0, host: '' localhost:27017 '' } ]})" '
    depends_on :
      - mongo

  hubot-natural :
    build : .
    restart : unless-stopped
    environment :
      - HUBOT_ADAPTER=rocketchat
      - HUBOT_NAME='Hubot Natural'
      - HUBOT_OWNER=RocketChat
      - HUBOT_DESCRIPTION='Hubot natural language processing'
      - HUBOT_LOG_LEVEL=debug
      - HUBOT_CORPUS=corpus.yml
      - HUBOT_LANG=pt
      - RESPOND_TO_DM=true
      - RESPOND_TO_LIVECHAT=true
      - RESPOND_TO_EDITED=true
      - LISTEN_ON_ALL_PUBLIC=false
      - ROCKETCHAT_AUTH=password
      - ROCKETCHAT_URL=rocketchat:3000
      - ROCKETCHAT_ROOM=GENERAL
      - ROCKETCHAT_USER=botnat
      - ROCKETCHAT_PASSWORD=botnatpass
      - HUBOT_NATURAL_DEBUG_MODE=true
    volumes :
      - ./scripts:/home/hubotnat/bot/scripts
      - ./training_data:/home/hubotnat/bot/training_data
    depends_on :
      - rocketchat
    ports :
      - 3001:8080

Vous pouvez modifier les attributs des variables et des volumes selon vos besoins spécifiques et exécuter docker-compose up dans le terminal pour démarrer le service rocketchat à http://localhost:3000 . ATTENTION : vous devez vous rappeler que hubot doit avoir un véritable utilisateur rocketchat créé pour se connecter. Ainsi, la première fois que vous exécutez ceci, vous devez d'abord accéder à rocketchat et créer un nouvel utilisateur pour hubot, modifier les variables ROCKETCHAT_USER et ROCKETCHAT_PASSWORD dans le fichier docker-compose.yml, puis recharger les services en utilisant docker-compose stop && docker-compose up pour tout recommencer.

Si vous souhaitez exécuter uniquement le service hubot-natural pour connecter une instance déjà en cours d'exécution de Rocket.Chat, n'oubliez pas de définir ROCKETCHAT_URL sur une valeur correcte, comme https://open.rocket.chat .

Configuration du robot

Afin d'utiliser correctement Hubot Natural, après avoir exécuté la commande docker-compose up , il est nécessaire d'effectuer quelques étapes de configuration. Pour ce faire, il existe deux options principales :

La première consiste à effectuer manuellement les étapes décrites dans la documentation de configuration du bot.

La deuxième option consiste à exécuter le script bot_config.py , situé dans le répertoire racine du projet. Cela configurera automatiquement le bot en fonction des variables suivantes définies dans le script : admin_name, admin_password, bot_name et bot_password . Il est important de rappeler de bien définir les valeurs de ces variables en fonction du contexte. Les valeurs utilisées sur bot_name et bot_password doivent être les mêmes que celles définies sur docker-compose.yml, respectivement sur les variables ROCKETCHAT_USER et ROCKETCHAT_PASSWORD . Et les valeurs définies dans les variables admin_name et admin_password doivent être les informations d'identification d'un utilisateur préexistant sur rocketchat, qui dispose des autorisations d'administrateur.

Pour créer automatiquement un utilisateur administrateur, avant d'exécuter les services, définissez simplement les variables ADMIN_USERNAME et ADMIN_PASS pour le service rocketchat sur docker-compose.yml .

Déployer avec Hubot

Pour déployer HubotNatural, vous devez d'abord installer votre hubot-generator :

npm install -g yo generator-hubot

Ensuite, vous clonerez le référentiel HubotNatural :

git clone https://github.com/RocketChat/hubot-natural.git mybot

Remplacez « mybot » dans la commande git clone ci-dessus par le nom de votre bot et installez les binaires hubot, sans écraser aucun des fichiers du dossier :

 cd mybot
npm install
yo hubot

                     _____________________________
                    /                             
   //               |      Extracting input for    |
  ////     _____    |   self-replication process   |
 //////   /_____                                 /
 ======= | [^_/ _ ] |   /----------------------------
  |   | _ | ___@@__ | __
  +===+/  ///     _ 
   | | _  /// HUBOT/ \
   | ___/ / /      /  \
               /   +---+
          _ ___/    |   |
           | // |    +===+
            / /      | xx |

? Owner Diego < [email protected] >
? Bot name mybot
? Description A simple helpful chatbot for your Company
? Bot adapter rocketchat
   create bin/hubot
   create bin/hubot.cmd
 conflict Procfile
? Overwrite Procfile ? do not overwrite
     skip Procfile
 conflict README.md
? Overwrite README.md ? do not overwrite
     skip README.md
   create external-scripts.json
   create hubot-scripts.json
 conflict .gitignore
? Overwrite .gitignore ? do not overwrite
     skip .gitignore
 conflict package.json
? Overwrite package.json ? do not overwrite
     skip package.json
   create scripts/example.coffee
   create .editorconfig

Maintenant, pour exécuter votre chatbot en shell, vous devez exécuter :

bin/hubot

attendez une minute pour le processus de chargement, puis vous pourrez parler à mybot.

Jetez un œil aux adaptateurs pour exécuter votre bot sur d’autres plates-formes.

Configurer le transfert en direct

Il est possible de configurer Hubot Natural pour rediriger la conversation vers une personne réelle, dans les moments où le bot ne peut pas aider les utilisateurs autant que nécessaire. Pour activer et configurer la fonctionnalité Live Transfer , suivez les étapes décrites dans la documentation de configuration du transfert en direct.

Variables d'environnement :

Dans la fenêtre de votre terminal, exécutez :

 export HUBOT_ADAPTER=rocketchat
export HUBOT_OWNER=RocketChat
export HUBOT_NAME= ' Bot Name '
export HUBOT_DESCRIPTION= ' Description of your bot '
export ROCKETCHAT_URL=https://open.rocket.chat
export ROCKETCHAT_ROOM=GENERAL
export LISTEN_ON_ALL_PUBLIC=false
export RESPOND_TO_DM=true
export RESPOND_TO_LIVECHAT=true
export ROCKETCHAT_USER=catbot
export ROCKETCHAT_PASSWORD= ' bot password '
export ROCKETCHAT_AUTH=password
export HUBOT_LOG_LEVEL=debug
export HUBOT_CORPUS= ' corpus.yml '
export HUBOT_LANG= ' en '
bin/hubot -a rocketchat --name $HUBOT_NAME

Vous pouvez consulter le projet d'adaptateur hubot-rocketchat pour plus de détails.

Fichier Json PM2

En tant que développeurs NodeJS, nous avons appris à aimer Process Manager PM2 et nous vous encourageons vraiment à l'utiliser.

npm install pm2 -g

Créez un fichier mybot.json et définissez son contenu comme suit :

{
	"apps" : [{
		"name" : " mybot " ,
		"interpreter" : " /bin/bash " ,
		"watch" : true ,
		"ignore_watch" : [ " client/img " ],
		"script" : " bin/hubot " ,
		"args" : " -a rocketchat " ,
		"port" : " 3001 " ,
		"env" : {
			"ROCKETCHAT_URL" : " https://localhost:3000 " ,
			"ROCKETCHAT_ROOM" : " general " ,
			"RESPOND_TO_DM" : true ,
			"ROCKETCHAT_USER" : " mybot " ,
			"ROCKETCHAT_PASSWORD" : " 12345 " ,
			"ROCKETCHAT_AUTH" : " password " ,
			"HUBOT_LOG_LEVEL" : " debug "
		}
	}
]
}

Vous pouvez également instancier plusieurs processus avec PM2, si vous souhaitez par exemple exécuter plusieurs instances de votre bot :

{
	"apps" : [{
		"name" : " mybot.0 " ,
		"interpreter" : " /bin/bash " ,
		"watch" : true ,
		"ignore_watch" : [ " client/img " ],
		"script" : " bin/hubot " ,
		"args" : " -a rocketchat " ,
		"port" : " 3001 " ,
		"env" : {
			"ROCKETCHAT_URL" : " https://localhost:3000 " ,
			"ROCKETCHAT_ROOM" : " general " ,
			"RESPOND_TO_DM" : true ,
			"ROCKETCHAT_USER" : " mybot " ,
			"ROCKETCHAT_PASSWORD" : " 12345 " ,
			"ROCKETCHAT_AUTH" : " password " ,
			"HUBOT_LOG_LEVEL" : " debug "
		}
	}, {
		"name" : " mybot.1 " ,
		"interpreter" : " /bin/bash " ,
		"watch" : true ,
		"ignore_watch" : [ " client/img " ],
		"script" : " bin/hubot " ,
		"args" : " -a rocketchat " ,
		"port" : " 3002 " ,
		"env" : {
			"ROCKETCHAT_URL" : " https://mycompany.rocket.chat " ,
			"ROCKETCHAT_ROOM" : " general " ,
			"RESPOND_TO_DM" : true ,
			"ROCKETCHAT_USER" : " mybot " ,
			"ROCKETCHAT_PASSWORD" : " 12345 " ,
			"ROCKETCHAT_AUTH" : " password " ,
			"HUBOT_LOG_LEVEL" : " debug "
		}
	}
]
}

Et bien sûr, vous pouvez devenir fou en définissant des configurations pour différentes plateformes, comme Facebook Mensenger, Twitter ou Telegram ;P.

Adaptateurs Hubot

Hubot est livré avec au moins 38 adaptateurs, dont bien sûr l'adaptateur Rocket.Chat.
Pour vous connecter à votre instance Rocket.Chat, vous pouvez définir des variables d'environnement, notre fichier de configuration pm2 json.

Découvrez d'autres adaptateurs Hubot pour plus d'informations.

Grâce à

Chez Rocket.Chat, nous sommes tellement amoureux de ce que nous faisons que nous ne pouvions pas oublier de remercier tous ceux qui ont rendu cela possible !

L'équipe Github Hubot

Merci les gars pour ce cadre incroyable, les hubots vivent au cœur de Rocket.Chat, et nous recommandons à tout le monde de consulter https://hubot.github.com et d'en savoir beaucoup plus sur hubot !

Projet de nœud naturel

À l'équipe NaturalNode, nos plus sincères "MERCI BEAUCOUP !! Nous avons adoré votre projet et nous sommes ravis de contribuer !".
Consultez https://github.com/NaturalNode/natural et laissez-vous époustoufler !

Le Heartbot de Digital Ocean

Nous ne remercierons jamais assez Digital Ocean, non seulement pour ce magnifique projet HeartBot, mais aussi pour tous les excellents tutoriels et toutes les contributions au mouvement OpenSource.

Merci à notre communauté

Et enfin, merci à notre grande communauté de contributeurs, de testeurs, d'utilisateurs, de partenaires et de tous ceux qui aiment Rocket.Chat et qui ont rendu tout cela possible.

Développer