hubot natural

Hubot Natural

Chatbot de linguagem natural

Hubot é uma das estruturas de criação de bots mais famosas da web, isso porque o github facilitou sua criação. Se você pode definir seus comandos em um parâmetro RegExp, basicamente você pode fazer qualquer coisa com o Hubot. Essa é uma grande contribuição para a cultura ChatOps.

Inspirados por isso, queríamos fornecer a mesma simplicidade à nossa comunidade para desenvolver chatbots que pudessem realmente processar linguagem natural e executar tarefas, tão fáceis quanto construir bots orientados a RegExp.

Então, encontramos um projeto realmente charmoso para iniciar, o Digital Ocean's Heartbot , uma dose de amor para seu cliente de chat favorito =)

Com base no Heartbot, apresentamos algum poder de PNL da equipe NaturalNode, uma coleção impressionante de bibliotecas de processamento de linguagem natural feitas para serem usadas em NodeJS.

E assim, a mágica acontece...

Bem-vindo ao HubotNatural , uma nova e emocionante estrutura de chatbot baseada nas bibliotecas Hubot e NaturalNode, com uma arquitetura simples e extensível projetada pela equipe HeartBot da Digital Ocean, feita com amor e carinho pela equipe Rocket.Chat.

Esperamos que você goste do projeto e encontre algum tempo para contribuir.

Como funciona

O HubotNatural foi feito para ser fácil de treinar e estender. Então, o que você precisa entender basicamente é que ele possui um corpus YAML, onde você pode projetar suas interações de chatbot usando nada além da notação YAML.

Todas as interações YAML projetadas em corpus podem ter parâmetros próprios, que serão processados ​​por uma classe de evento.

As classes de eventos oferecem a possibilidade de estender o HubotNatural. Ao escrever suas próprias classes de eventos, você pode dar ao seu chatbot as habilidades para interagir com qualquer serviço necessário.

Corpus YAML

O arquivo YAML é carregado em scripts/index.js , analisado e passado para o chatbot bind, que será encontrado em scripts/bot/index.js , o córtex do bot, onde todo o fluxo e controle de informações são programados.

O corpus YAML está localizado em training_data/corpus.yml e sua estrutura básica é semelhante a esta:

 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

O que esta sintaxe significa:

• trust : o nível mínimo de certeza que deve ser retornado pelo classificador para executar esta interação. O valor é de 0 a 1 (0% a 100%). Se um classificador retornar um valor de certeza menor que trust , os bots responderão com um nó de interação de erro.
• interactions : um vetor com muitos nós de interação que serão analisados. Cada interação projetada para o seu chatbot deve estar sob uma estrutura de objeto interact.node.
• name : é o nome exclusivo da interação pela qual ela será identificada. Não crie mais de uma interação com o mesmo atributo node.name .
• expect : Essas são as sentenças que serão dadas ao treinamento dos bots. Eles podem ser strings ou vetores de palavras-chave, como ['consume','use'] .
• answer : as mensagens que serão enviadas ao usuário, caso os classificadores sejam classificados acima do nível de confiança. O node.message será analisado e enviado por classe de evento. Para usar strings multilinhas dentro de seu YAML, você deve seguir a sintaxe YAML Multiline Strings. Você pode especificar variáveis ​​na mensagem. Por padrão, o HubotNatural vem com variáveis $user , $bot e $room .
• event : é o nome da classe CoffeeScript ou JavaScript dentro de scripts/events , sem a extensão do arquivo.

Aulas de café para eventos

Classes de eventos podem ser escritas para ampliar as habilidades do chatbot. Eles recebem o objeto de interação e analisam a mensagem, assim:

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

module.exports = respond

Seu construtor base é o nó @interaction para que você possa ter acesso a todos os atributos dentro de uma interação apenas usando @interaction.attribute . Aqui você pode analisar textos, chamar APIs, ler arquivos, acessar bancos de dados e tudo mais que precisar.
Você pode usar a função stringElseRandomKey para obter um elemento aleatório de uma lista, se o parâmetro for uma lista, e usar a função sendMessages para enviar mensagens a um usuário.

Classificador de regressão logística

A biblioteca NaturalNode vem com dois tipos de classificadores, o classificador Naive Bayes conhecido como BayesClassifier e as funções LogisticRegressionClassifier . Por padrão, HubotNatural usa LogisticRegressionClassifier . Ele simplesmente veio com melhores resultados em nossos testes.

PorterStemmer

Também existe mais de um tipo de lematizador. Você deve definir o lematizador para definir seu idioma. Por padrão usamos o PorterStemmerPt para português, mas você pode encontrar lematizadores de inglês, russo, italiano, francês, espanhol e outros nas bibliotecas do NaturalNode, ou até mesmo escrever seus próprios lematizadores com base neles.

Basta verificar dentro de node_modules/natural/lib/natural/stemmers/ .

Para alterar o idioma dos lematizadores, basta definir a variável de ambiente HUBOT_LANG como pt , en , es e qualquer outra terminação de idioma que corresponda a um arquivo lematizador dentro do diretório acima.

Implantar com Docker

Temos um Dockerfile que cria uma imagem leve baseada em Linux Alpine com todo o conteúdo do repositório para que você possa fazer upload dessa imagem para um registro docker e implantar seu chatbot a partir daí. Ele está localizado na pasta docker .

Você também pode usar o arquivo docker-compose.yml para carregar uma instância local dos serviços Rocket.Chat, MongoDB e HubotNatural, onde você pode alterar os parâmetros, se necessário.

O arquivo docker-compose fica assim:

 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

Você pode alterar os atributos de variáveis ​​e volumes de acordo com suas necessidades específicas e executar docker-compose up no terminal para iniciar o serviço rocketchat em http://localhost:3000 . ATENÇÃO: Você deve lembrar que o hubot deve ter um usuário real do rocketchat criado para fazer o login. Portanto, na primeira vez que você executar isso, você deve primeiro entrar no rocketchat e criar um novo usuário para o hubot, alterar as variáveis ROCKETCHAT_USER e ROCKETCHAT_PASSWORD no arquivo docker-compose.yml e, em seguida, recarregar os serviços usando docker-compose stop && docker-compose up para começar tudo de novo.

Se você deseja executar apenas o serviço hubot-natural para conectar uma instância já em execução do Rocket.Chat, você só precisa se lembrar de definir ROCKETCHAT_URL com um valor correto, como https://open.rocket.chat .

Configuração do bot

Para utilizar corretamente o Hubot Natural, após executar o comando docker-compose up , é necessário realizar alguns passos de configuração. Para fazer isso, existem duas opções principais:

A primeira é executar manualmente os passos descritos na documentação de configuração do bot.

A segunda opção é executar o script bot_config.py , localizado no diretório raiz do projeto. Isso configurará automaticamente o bot com base nas seguintes variáveis ​​definidas no script: admin_name, admin_password, bot_name e bot_password . É importante lembrar de definir corretamente os valores destas variáveis ​​de acordo com o contexto. Os valores utilizados em bot_name e bot_password devem ser os mesmos definidos em docker-compose.yml, nas variáveis ROCKETCHAT_USER e ROCKETCHAT_PASSWORD respectivamente. E os valores definidos nas variáveis admin_name e admin_password devem ser as credenciais de um usuário pré-existente no rocketchat, que tenha permissões de administrador.

Para criar um usuário administrador automaticamente, antes de executar os serviços, basta definir as variáveis ADMIN_USERNAME e ADMIN_PASS para o serviço rocketchat em docker-compose.yml .

Implantar com Hubot

Para implantar o HubotNatural, primeiro você deve instalar o seu hubot-generator:

npm install -g yo generator-hubot

Então você clonará o repositório HubotNatural:

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

Altere 'mybot' no comando git clone acima para qualquer que seja o nome do seu bot e instale os binários do hubot, sem confundir nenhum dos arquivos dentro da pasta:

 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

Agora, para executar seu chatbot em shell, você deve executar:

bin/hubot

espere um minuto pelo processo de carregamento e então você poderá falar com mybot.

Dê uma olhada nos adaptadores para rodar seu bot em outras plataformas.

Configurar transferência ao vivo

É possível configurar o Hubot Natural para redirecionar a conversa para uma pessoa real, nos momentos em que o bot não consegue ajudar os usuários tanto quanto necessário. Para ativar e configurar o recurso Live Transfer , siga as etapas descritas na documentação de configuração de transferência ao vivo.

Variáveis ​​ambientais:

Na janela do seu terminal, execute:

 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

Você pode verificar o projeto do adaptador hubot-rocketchat para obter mais detalhes.

Arquivo Json PM2

Como desenvolvedores de NodeJS, aprendemos a amar o Process Manager PM2 e realmente encorajamos você a usá-lo.

npm install pm2 -g

Crie um arquivo mybot.json e defina seu conteúdo como:

{
	"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 "
		}
	}
]
}

Você também pode instanciar mais de um processo com PM2, se quiser, por exemplo, executar mais de uma instância do seu 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 "
		}
	}
]
}

E claro, você pode enlouquecer definindo configurações para diferentes plataformas, como facebook mensenger, twitter ou telegram ;P.

Adaptadores Hubot

O Hubot vem com pelo menos 38 adaptadores, incluindo o adaptador Rocket.Chat, é claro.
Para se conectar à sua instância Rocket.Chat, você pode definir variáveis ​​​​env, nosso arquivo json de configuração pm2.

Confira outros adaptadores hubot para obter mais informações.

Graças a

Na Rocket.Chat somos tão apaixonados pelo que fazemos que não poderíamos esquecer de agradecer a todos que tornaram isso possível!

Equipe Hubot do Github

Obrigado pessoal por esta estrutura incrível, o hubots vive no coração do Rocket.Chat, e recomendamos a todos que façam check-in em https://hubot.github.com e descubram muito mais sobre o hubot!

Projeto Nó Natural

À Equipe NaturalNode nosso mais sincero "MUITO OBRIGADO!! Adoramos seu projeto e estamos ansiosos para contribuir!".
Confira https://github.com/NaturalNode/natural e deixe sua mente explodir!

Heartbot da Digital Ocean

Não podemos agradecer o suficiente à Digital Ocean, não apenas por este lindo projeto HeartBot, mas também por todos os ótimos tutoriais e todas as contribuições para o movimento OpenSource.

Obrigado à nossa comunidade

E por último, mas não menos importante, obrigado à nossa grande comunidade de colaboradores, testadores, usuários, parceiros e todos que amam o Rocket.Chat e tornaram tudo isso possível.