chatto

bavarder

Framework de chatbot simple écrit en Go, avec des configurations en YAML. Le but de ce projet est de créer des chatbots textuels très simples en utilisant quelques fichiers de configuration.

L'inspiration pour ce projet est venue à l'origine de Flottbot et de mon expérience avec Rasa.

Contenu

• Installation

• Documentation

• Votre premier robot

• Le fichier clf.yml

• Le fichier fsm.yml

• Exécutez votre bot

• Interagissez avec votre bot

• Usage

• CLI

• Docker Composer

• Kubernetes

• Importer

• Exemples

Installation

go get -u github.com/jaimeteb/chatto

Via Docker :

docker pull jaimeteb/chatto:latest

Documentation

Consultez la documentation pour des exemples , des guides de configuration et des références .

Votre premier robot

Chatto combine la cohérence d'une machine à états finis avec la flexibilité de l'apprentissage automatique. Il comporte trois composants principaux : le classificateur, la machine à états finis et les extensions.

Une structure de répertoires très basique pour Chatto serait la suivante :

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

Commencez par créer le répertoire data ainsi que les fichiers YAML.

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

Le fichier clf.yml

Le fichier clf.yml définit comment les messages utilisateur seront classés en commandes (intents). Commencez par cette configuration très simple :

 classification:
  - commande : "turn_on"textes :
      - "allumer" - "allumer"

  - commande : "turn_off"textes :
      - "éteindre" - "éteindre"

Le fichier fsm.yml

Le fichier fsm.yml définit les transitions entre états, les commandes qui effectuent ces transitions, et les réponses à y envoyer. Commencez par le contenu de ce fichier :

 transitions :
  - depuis:
      - "initial"dans : "on"commande : "turn_on"réponses :
      - texte : "Allumer".

  - depuis:
      - "on"dans : commande "initiale" : "turn_off"réponses :
      - texte : "Éteindre".  - texte : ""valeurs par défaut : inconnu : "Impossible de faire ça."

Exécutez votre premier bot

Pour démarrer votre bot, exécutez :

 chatto --chemin de données/

Si vous utilisez Docker, exécutez :

 exécution du docker
     -il
     -e CHATTO_DATA=./données
     -v $PWD/données:/données
     jaimeteb/chatto:dernier
     chatto --chemin des données

Interagissez avec votre premier bot

Pour interagir avec votre bot, exécutez :

chatto cli

C'est ça! Vous pouvez maintenant dire "allumer" ou " allumer" pour passer à l'état activé , et "éteindre" ou "éteindre" pour revenir à l' état initial . Cependant, vous ne pouvez pas non plus passer de on à on , ni de initial à initial .

Voici un schéma de cette simple machine à états finis :

Usage

Vous pouvez intégrer votre bot avec Telegram, Twilio, Slack et tout ce que vous voulez

Exécutez chatto dans le répertoire où se trouvent vos fichiers YAML, ou spécifiez un chemin d'accès avec l'indicateur --path :

 chatto --path ./votre/données

Pour exécuter sur Docker, utilisez :

 exécution du docker
   -p 4770:4770
   -e CHATTO_DATA=./votre/données
   -v $PWD/votre/données:/données
   jaimeteb/chatto

CLI

Vous pouvez utiliser l'outil Chatto CLI en téléchargeant l'outil chatto cli . La CLI facilite le test des interactions de votre robot.

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

Docker Composer

Vous pouvez également utiliser Chatto sur Docker Compose. Un docker-compose.yml ressemblerait à ceci :

 version : "3"services : chatto:image: jaimeteb/chatto:${CHATTO_VERSION}env_file : .envports :
      -Volumes "4770:4770":
      - ${CHATTO_DATA} :/datadepends_on :
      -ext-redis

  ext:image: odise/busybox-curl # Boîte occupée avec commande de certificats : ext/extexpose :
      - 8770volumes :
      - ${CHATTO_DATA}/ext:/ext

  redis:image : bitnami/redis:6.0environnement :
      - REDIS_PASSWORD=${STORE_PASSWORD}expose :
      - 6379

Cela nécessite un fichier .env contenant les variables d'environnement nécessaires :

# 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

La structure des répertoires avec tous les fichiers ressemblerait à ceci :

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

Enfin, exécutez :

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

Le serveur d'extensions doit être exécuté selon sa langue.

Pour ce fichier docker-compose.yml , vous devez d'abord créer l'extension Go :

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

Le serveur d'extensions doit être en cours d'exécution avant l'initialisation de Chatto.

Kubernetes

Sous le répertoire deploy/kubernetes , vous pouvez trouver un exemple de déploiement :

Gentil	Nom	Description
Secrète	chatto-config-secrets	Contient les jetons que Chatto utilisera pour l'autorisation
Carte de configuration	chatto-config-envs	Contient les variables d'environnement du fichier bot.yml
Carte de configuration	chatto-config-files	Contient les fichiers clf.yml et fsm.yml
Déploiement	chatto	Déploiement Chatto basé sur l'image Docker jaimeteb/chatto
Service	chatto-service	Service pour le déploiement chatto
Entrée	chatto-ingress	Entrée pour le service chatto-service

Exécutez la commande suivante pour déployer sur Kubernetes :

 kubectl apply -f ./deploy/kubernetes/

Importer

Un serveur de robots et un package client importables sont fournis pour permettre l'intégration dans votre propre application.

Pour intégrer le serveur :

 package mainimport ( "flag""github.com/jaimeteb/chatto/bot")func main() { port := flag.Int("port", 4770, "Spécifiez le port à utiliser.") path := flag.String ("chemin", ".", "Chemin d'accès aux fichiers YAML.") flag.Parse() serveur := bot.NewServer(*chemin, *port) serveur.Run()
}

Pour intégrer le client :

 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, port)}
}func (s *MyService) Submit(question *query.Question) error { réponses, err := s.chatto.Submit(question) if err != nil { return err
	} // Imprimer les réponses sur stdoutfor _, réponse := plage de réponses { fmt.Println(answer.Text)
	} renvoie zéro}

Exemples

J'ai fourni quelques fichiers de configuration sous exemples . Clonez le référentiel et exécutez chatto avec le -path de l'exemple souhaité pour les tester (pour ceux qui utilisent des extensions, exécutez d'abord leurs extensions respectives).

Plus d'informations sur ces exemples dans la documentation

1. Mood Bot - Une version chatto du Mood Bot de Rasa. Saluez le bot pour démarrer la conversation.

2. Recherche Pokémon - Recherchez des Pokémon par nom ou par numéro.

3. Trivia Quiz - Tapez start pour répondre à un quiz rapide.