chatto

chato

Marco de chatbot simple escrito en Go, con configuraciones en YAML. El objetivo de este proyecto es crear chatbots basados ​​en texto muy simples utilizando algunos archivos de configuración.

La inspiración para este proyecto vino originalmente de Flottbot y de mi experiencia con Rasa.

Contenido

• Instalación

• Documentación

• Tu primer robot

• El archivo clf.yml

• El archivo fsm.yml

• Ejecute su robot

• Interactúa con tu bot

• Uso

• CLI

• Composición acoplable

• Kubernetes

• Importar

• Ejemplos

Instalación

go get -u github.com/jaimeteb/chatto

A través de Docker:

docker pull jaimeteb/chatto:latest

Documentación

Consulte la documentación para obtener ejemplos , guías de configuración y referencias .

Tu primer robot

Chatto combina la consistencia de una máquina de estados finitos con la flexibilidad del aprendizaje automático. Tiene tres componentes principales: el clasificador, la máquina de estados finitos y las extensiones.

Una estructura de directorios muy básica para Chatto sería la siguiente:

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

Comience creando el directorio data y los archivos YAML.

 mkdir datos táctiles datos/clf.yml datos/fsm.yml

El archivo clf.yml

El archivo clf.yml define cómo se clasificarán los mensajes del usuario en comandos (intenciones). Comience con esta configuración muy simple:

 clasificación:
  - comando: "turn_on"textos:
      - "encender" - "encender"

  - comando: "turn_off"textos:
      - "apagar" - "apagar"

El archivo fsm.yml

El archivo fsm.yml define las transiciones entre estados, los comandos que realizan estas transiciones y las respuestas que se enviarán en ellos. Comience con el contenido de este archivo:

 transiciones:
  - de:
      - "inicial" en: "on" comando: "turn_on" respuestas:
      - texto: "Encendiendo".

  - de:
      - "on" en: comando "inicial": "turn_off" respuestas:
      - texto: "Apagando".  - texto: ""valores predeterminados: desconocido: "No puedo hacer eso".

Ejecuta tu primer bot

Para iniciar su bot, ejecute:

 chatto --datos de ruta/

Si estás usando Docker, ejecuta:

 ejecución de la ventana acoplable
     -él
     -e CHATTO_DATA=./datos
     -v $contraseña/datos:/datos
     jaimeteb/chatto:último
     chatto --datos de ruta

Interactúa con tu primer bot

Para interactuar con tu bot, ejecuta:

chatto cli

¡Eso es todo! Ahora puede decir encender o encender para volver al estado encendido y apagar o apagar para volver al estado inicial . Sin embargo, no se puede pasar de inicial a inicial , ni tampoco de inicial a inicial .

Aquí hay un diagrama para esta simple máquina de estados finitos:

Uso

Puedes integrar tu bot con Telegram, Twilio, Slack y lo que quieras

Ejecute chatto en el directorio donde se encuentran sus archivos YAML, o especifique una ruta a ellos con el indicador --path :

 chatto --ruta ./tu/datos

Para ejecutar en Docker, use:

 ejecución de la ventana acoplable
   -p 4770:4770
   -e CHATTO_DATA=./tus/datos
   -v $PWD/tu/datos:/datos
   jaimeteb/chatto

CLI

Puede utilizar la herramienta Chatto CLI descargando la herramienta chatto cli . La CLI facilita la prueba de las interacciones de sus bots.

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

Composición acoplable

También puedes usar Chatto en Docker Compose. Un docker-compose.yml se vería así:

 versión: "3"servicios: chatto:imagen: jaimeteb/chatto:${CHATTO_VERSION}env_file: .envports:
      - volúmenes "4770:4770":
      - ${CHATTO_DATA}:/datadepends_on:
      -ext-redis

  ext:image: odise/busybox-curl # Cuadro ocupado con certificadoscomando: ext/extexpose:
      - 8770 volúmenes:
      - ${CHATTO_DATA}/ext:/ext

  redis:imagen: bitnami/redis:6.0entorno:
      - REDIS_PASSWORD=${STORE_PASSWORD}exponer:
      - 6379

Esto requiere un archivo .env que contenga las variables de entorno necesarias:

# 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 estructura del directorio con todos los archivos se vería así:

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

Finalmente, ejecuta:

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

El servidor de extensiones debe ejecutarse según su idioma.

Para este archivo docker-compose.yml , primero deberá crear la extensión Go:

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

El servidor de extensiones debe estar ejecutándose antes de que se inicialice Chatto.

Kubernetes

En el directorio deploy/kubernetes puede encontrar una implementación de ejemplo:

Amable	Nombre	Descripción
Secreto	chatto-config-secrets	Contiene los tokens que Chatto utilizará para la autorización.
Mapa de configuración	chatto-config-envs	Contiene las variables de entorno para el archivo bot.yml.
Mapa de configuración	chatto-config-files	Contiene el archivo clf.yml y fsm.yml
Despliegue	chatto	Implementación de Chatto basada en la imagen de Docker jaimeteb/chatto
Servicio	chatto-service	Servicio para el despliegue chatto
Ingreso	chatto-ingress	Ingreso para el servicio chatto-service

Ejecute el siguiente comando para implementar en Kubernetes:

 kubectl aplicar -f ./deploy/kubernetes/

Importar

Se proporciona un servidor de bot importable y un paquete de cliente para permitir la integración en su propia aplicación.

Para insertar el servidor:

 paquete mainimport ( "flag""github.com/jaimeteb/chatto/bot")func main() { puerto := flag.Int("puerto", 4770, "Especifique el puerto a usar.") ruta := flag.String ("ruta", ".", "Ruta a archivos YAML.") flag.Parse() servidor := bot.NewServer(*ruta, *puerto) server.Run()
}

Para insertar el cliente:

 paquete myserviceimport ( "log" "github.com/jaimeteb/chatto/bot") escriba MyService struct { chatto bot.Client}func NewMyService(cadena de URL, puerto int) *MyService { return &MyService{chatto: bot.NewClient(url, puerto)}
}func (s *MiServicio) Enviar(pregunta *consulta.Pregunta) error { respuestas, err := s.chatto.Submit(pregunta) si err != nil { return err
	} // Imprime respuestas a stdoutfor _, respuesta := rango de respuestas { fmt.Println(answer.Text)
	} devolver nulo}

Ejemplos

He proporcionado algunos archivos de configuración en los ejemplos . Clona el repositorio y ejecuta chatto con la -path del ejemplo que desees para probarlos (para los que usan extensiones, ejecuta sus respectivas extensiones primero).

Más sobre estos ejemplos en la Documentación

1. Mood Bot : una versión chatto del Mood Bot de Rasa. Saluda al bot para iniciar la conversación.

2. Búsqueda de Pokémon : busca Pokémon por nombre o número.

3. Prueba de trivia : escriba comenzar para realizar una prueba de trivia rápida.