chatto

bate-papo

Framework simples de chatbot escrito em Go, com configurações em YAML. O objetivo deste projeto é criar chatbots baseados em texto muito simples usando alguns arquivos de configuração.

A inspiração para este projeto veio originalmente do Flottbot e da minha experiência com o Rasa.

Conteúdo

• Instalação

• Documentação

• Seu primeiro bot

• O arquivo clf.yml

• O arquivo fsm.yml

• Execute seu bot

• Interaja com seu bot

• Uso

• CLI

• Composição do Docker

• Kubernetes

• Importar

• Exemplos

Instalação

go get -u github.com/jaimeteb/chatto

Através do Docker:

docker pull jaimeteb/chatto:latest

Documentação

Consulte a documentação para exemplos , guias de configuração e referência .

Seu primeiro bot

Chatto combina a consistência de uma máquina de estados finitos com a flexibilidade do aprendizado de máquina. Possui três componentes principais: o classificador, a máquina de estados finitos e as extensões.

Uma estrutura de diretórios muito básica para Chatto seria a seguinte:

.
└──data
   ├── clf.yml
   └── fsm.yml

Comece criando o diretório data , bem como os arquivos YAML.

 mkdir datatouch data/clf.yml data/fsm.yml

O arquivo clf.yml

O arquivo clf.yml define como as mensagens do usuário serão classificadas em comandos (intents). Comece com esta configuração muito simples:

 classificação:
  - comando: "turn_on"textos:
      - "ligar" - "ligar"

  - comando: textos "turn_off":
      - "desligar" - "desligar"

O arquivo fsm.yml

O arquivo fsm.yml define as transições entre estados, os comandos que fazem essas transições e as respostas a serem enviadas neles. Comece com o conteúdo deste arquivo:

 transições:
  - de:
      - "initial"into: "on"command: "turn_on"respostas:
      - texto: "Ligando."

  - de:
      - "on"into: "initial"comando: "turn_off"respostas:
      - texto: "Desligando."  - text: ""defaults: desconhecido: "Não posso fazer isso."

Execute seu primeiro bot

Para iniciar seu bot, execute:

 chatto --caminho dados/

Se você estiver usando Docker, execute:

 execução do docker
     -isto
     -e CHATTO_DATA=./dados
     -v $PWD/dados:/dados
     jaimeteb/chatto:mais recente
     chatto --caminho dados

Interaja com seu primeiro bot

Para interagir com seu bot, execute:

chatto cli

É isso! Agora você pode dizer ligar ou ligar para entrar no estado ligado e desligar ou desligar para voltar ao estado inicial . No entanto, você não pode passar de on para on ou de inicial para inicial .

Aqui está um diagrama para esta máquina de estados finitos simples:

Uso

Você pode integrar seu bot com Telegram, Twilio, Slack e o que quiser

Execute chatto no diretório onde seus arquivos YAML estão localizados ou especifique um caminho para eles com o sinalizador --path :

 chatto --path ./seus/dados

Para rodar no Docker, use:

 execução do docker
   -p4770:4770
   -e CHATTO_DATA=./seus/dados
   -v $PWD/seu/dados:/dados
   jaimeteb/chato

CLI

Você pode usar a ferramenta Chatto CLI baixando a ferramenta chatto cli . A CLI facilita o teste das interações do bot.

 chatto cli --url 'http://mybot.com' -port 4770

Composição do Docker

Você também pode usar o Chatto no Docker Compose. Um docker-compose.yml ficaria assim:

 versão: "3"serviços: chatto:image: jaimeteb/chatto:${CHATTO_VERSION}env_file: .envports:
      - volumes "4770:4770":
      - ${CHATTO_DATA}:/datadepends_on:
      - ramal - redis

  ext:image: odise/busybox-curl # Caixa ocupada com certificadoscommand: ext/extexpose:
      - 8770 volumes:
      -${CHATTO_DATA}/ext:/ext

  redis:imagem:bitnami/redis:6.0ambiente:
      - REDIS_PASSWORD=${STORE_PASSWORD}expor:
      - 6379

Isso requer um arquivo .env para conter as variáveis ​​de ambiente necessárias:

# Chatto configuration
CHATTO_VERSION=latest
CHATTO_DATA=./your/data

# Extension configuration
CHATTO_BOT_EXTENSIONS_EXTENSION_NAME_URL=http://ext:8770

# Redis
CHATTO_BOT_STORE_HOST=redis
CHATTO_BOT_STORE_PASSWORD=pass

# Logs
CHATTO_BOT_DEBUG=true

A estrutura de diretórios com todos os arquivos ficaria assim:

.
├── data
│   ├── ext
│   │   ├── ext
│   │   └── ext.go
│   ├── bot.yml
│   ├── chn.yml
│   ├── clf.yml
|   └── fsm.yml
├── docker-compose.yml
└── .env

Finalmente, execute:

 docker-compose up -d redis ext
docker-compose up -d chatto

O servidor de extensões deve ser executado de acordo com sua linguagem.

Para este arquivo docker-compose.yml , você teria que construir a extensão Go primeiro:

go build -o data/ext/ext data/ext/ext.go

O servidor de extensões deve estar em execução antes da inicialização do Chatto.

Kubernetes

No diretório deploy/kubernetes você pode encontrar um exemplo de implantação:

Tipo	Nome	Descrição
Segredo	chatto-config-secrets	Contém os tokens que o Chatto usará para autorização
Mapa de configuração	chatto-config-envs	Contém as variáveis ​​de ambiente para o arquivo bot.yml
Mapa de configuração	chatto-config-files	Contém o arquivo clf.yml e fsm.yml
Implantação	chatto	Implantação do Chatto com base na imagem Docker jaimeteb/chatto
Serviço	chatto-service	Serviço para implantação do chatto
Entrada	chatto-ingress	Entrada para o serviço chatto-service

Execute o seguinte comando para implantar no Kubernetes:

 kubectl apply -f ./deploy/kubernetes/

Importar

Um servidor bot importável e um pacote de cliente são fornecidos para permitir a incorporação em seu próprio aplicativo.

Para incorporar o servidor:

 package mainimport ( "flag""github.com/jaimeteb/chatto/bot")func main() { port := flag.Int("port", 4770, "Especificar porta a ser usada.") path := flag.String ("caminho", ".", "Caminho para arquivos YAML.") flag.Parse() server := bot.NewServer(*path, *port) server.Run()
}

Para incorporar o cliente:

 package myserviceimport ( "log""github.com/jaimeteb/chatto/bot")type MyService struct { chatto bot.Client}func NewMyService(url string, port int) *MyService { return &MyService{chatto: bot.NewClient(url, porta)}
}func (s *MyService) Submit(question *query.Question) error {respostas, err := s.chatto.Submit(question) if err != nil { return err
	} // Imprime respostas para stdoutfor _, resposta := intervalo respostas { fmt.Println(answer.Text)
	} retornar nulo}

Exemplos

Forneci alguns arquivos de configuração em exemplos . Clone o repositório e execute chatto com o -path do exemplo desejado para testá-los (para aqueles que usam extensões, execute primeiro as respectivas extensões).

Mais sobre esses exemplos na Documentação

1. Mood Bot - Uma versão chatto do Mood Bot do Rasa Cumprimente o bot para iniciar a conversa.

2. Pesquisa Pokémon - Pesquise Pokémon por nome ou número.

3. Trivia Quiz - Digite start para fazer um rápido teste de curiosidades.