chatto

chatto

Einfaches Chatbot-Framework, geschrieben in Go, mit Konfigurationen in YAML. Ziel dieses Projekts ist es, mit wenigen Konfigurationsdateien sehr einfache textbasierte Chatbots zu erstellen.

Die Inspiration für dieses Projekt kam ursprünglich von Flottbot und meiner Erfahrung mit Rasa.

Inhalt

• Installation

• Dokumentation

• Dein erster Bot

• Die clf.yml- Datei

• Die fsm.yml- Datei

• Führen Sie Ihren Bot aus

• Interagieren Sie mit Ihrem Bot

• Verwendung

• CLI

• Docker Compose

• Kubernetes

• Import

• Beispiele

Installation

go get -u github.com/jaimeteb/chatto

Über Docker:

docker pull jaimeteb/chatto:latest

Dokumentation

Beispiele , Konfigurationshandbücher und Referenzen finden Sie in der Dokumentation .

Dein erster Bot

Chatto kombiniert die Konsistenz einer Finite-State-Maschine mit der Flexibilität des maschinellen Lernens. Es besteht aus drei Hauptkomponenten: dem Klassifikator, der Finite-State-Maschine und den Erweiterungen.

Eine sehr grundlegende Verzeichnisstruktur für Chatto wäre die folgende:

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

Erstellen Sie zunächst das data sowie die YAML-Dateien.

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

Die clf.yml- Datei

Die Datei clf.yml definiert, wie die Benutzernachrichten in Befehle (Absichten) klassifiziert werden. Beginnen Sie mit dieser sehr einfachen Konfiguration:

 Einstufung:
  - Befehl: „turn_on“Texte:
      - „einschalten“ – „ein“

  - Befehl: „turn_off“Texte:
      - „ausschalten“ – „aus“

Die fsm.yml- Datei

Die Datei fsm.yml definiert die Übergänge zwischen Zuständen, die Befehle, die diese Übergänge durchführen, und die darin zu sendenden Antworten. Beginnen Sie mit dem Inhalt dieser Datei:

 Übergänge:
  - aus:
      - „initial“into: „on“command: „turn_on“answers:
      - Text: „Einschalten.“

  - aus:
      - „on“into: „initial“command: „turn_off“answers:
      - Text: „Ausschalten.“  - text: „Standardwerte: unbekannt: „Das geht nicht.“

Führen Sie Ihren ersten Bot aus

Um Ihren Bot zu starten, führen Sie Folgendes aus:

 chatto --path data/

Wenn Sie Docker verwenden, führen Sie Folgendes aus:

 Docker-Lauf
     -Es
     -e CHATTO_DATA=./data
     -v $PWD/data:/data
     jaimeteb/chatto:latest
     chatto --path data

Interagieren Sie mit Ihrem ersten Bot

Um mit Ihrem Bot zu interagieren, führen Sie Folgendes aus:

chatto cli

Das ist es! Jetzt können Sie „einschalten“ oder „an“ sagen, um in den Ein -Zustand zu wechseln, und „aus“ oder „ausschalten “ , um in den ursprünglichen Zustand zurückzukehren. Sie können jedoch auch nicht von „on“ zu „on“ oder von „initial“ zu „initial“ wechseln.

Hier ist ein Diagramm für diese einfache Finite-State-Maschine:

Verwendung

Sie können Ihren Bot in Telegram, Twilio, Slack und alles integrieren, was Sie möchten

Führen Sie chatto in dem Verzeichnis aus, in dem sich Ihre YAML-Dateien befinden, oder geben Sie mit dem Flag --path einen Pfad zu ihnen an:

 chatto --path ./your/data

Zur Ausführung auf Docker verwenden Sie:

 Docker-Lauf
   -p 4770:4770
   -e CHATTO_DATA=./your/data
   -v $PWD/your/data:/data
   jaimeteb/chatto

CLI

Sie können das Chatto-CLI-Tool verwenden, indem Sie das chatto cli Tool herunterladen. Mit der CLI können Sie Ihre Bot-Interaktionen ganz einfach testen.

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

Docker Compose

Sie können Chatto auch auf Docker Compose verwenden. Eine docker-compose.yml würde so aussehen:

 Version: „3“Dienste: chatto:image: jaimeteb/chatto:${CHATTO_VERSION}env_file: .envports:
      - „4770:4770“-Bände:
      - ${CHATTO_DATA}:/datadepends_on:
      - ext - redis

  ext:image: odise/busybox-curl # Busy-Box mit ZertifikatenBefehl: ext/extexpose:
      - 8770 Bände:
      - ${CHATTO_DATA}/ext:/ext

  redis:image: bitnami/redis:6.0environment:
      - REDIS_PASSWORD=${STORE_PASSWORD}aussetzen:
      - 6379

Dazu ist eine .env Datei erforderlich, die die erforderlichen Umgebungsvariablen enthält:

# 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

Die Verzeichnisstruktur mit allen Dateien würde so aussehen:

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

Führen Sie abschließend Folgendes aus:

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

Der Erweiterungsserver muss entsprechend seiner Sprache ausgeführt werden.

Für diese docker-compose.yml Datei müssten Sie zuerst die Go-Erweiterung erstellen:

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

Der Erweiterungsserver muss ausgeführt werden, bevor Chatto initialisiert wird.

Kubernetes

Im Verzeichnis deploy/kubernetes finden Sie eine Beispielbereitstellung:

Art	Name	Beschreibung
Geheimnis	chatto-config-secrets	Enthält die Token, die Chatto zur Autorisierung verwendet
ConfigMap	chatto-config-envs	Enthält die Umgebungsvariablen für die bot.yml- Datei
ConfigMap	chatto-config-files	Enthält die Dateien clf.yml und fsm.yml
Einsatz	chatto	Chatto-Bereitstellung basierend auf dem Docker-Image jaimeteb/chatto
Service	chatto-service	Service für die chatto Bereitstellung
Eindringen	chatto-ingress	Eingang für den chatto-service -Dienst

Führen Sie den folgenden Befehl aus, um die Bereitstellung auf Kubernetes durchzuführen:

 kubectl apply -f ./deploy/kubernetes/

Import

Es wird ein importierbares Bot-Server- und Client-Paket bereitgestellt, um die Einbettung in Ihre eigene Anwendung zu ermöglichen.

So betten Sie den Server ein:

 Paket mainimport ("flag""github.com/jaimeteb/chatto/bot")func main() { port := flag.Int("port", 4770, "Zu verwendenden Port angeben.") path := flag.String ("Pfad", ".", "Pfad zu YAML-Dateien.") flag.Parse() server := bot.NewServer(*path, *port) server.Run()
}

So betten Sie den Client ein:

 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, Hafen)}
}func (s *MyService) Submit(question *query.Question) error { Antworten, err := s.chatto.Submit(question) if err != nil { return err
	} // Antworten auf stdout ausgebenfor _, Antwort := Bereich Antworten { fmt.Println(answer.Text)
	} null zurückgeben}

Beispiele

Unter Beispiele habe ich einige Konfigurationsdateien bereitgestellt. Klonen Sie das Repository und führen Sie chatto mit dem -path Ihres gewünschten Beispiels aus, um es zu testen (für diejenigen, die Erweiterungen verwenden, führen Sie zuerst die entsprechenden Erweiterungen aus).

Mehr zu diesen Beispielen in der Dokumentation

1. Mood Bot – Eine Chatto-Version von Rasas Mood Bot. Begrüßen Sie den Bot, um das Gespräch zu beginnen.

2. Pokémon-Suche – Suche nach Pokémon anhand des Namens oder der Nummer.

3. Wissenswertes-Quiz – Geben Sie „start“ ein, um an einem schnellen Wissensquiz teilzunehmen.