Skip to content

Home

Jump to bottom
Sébastien Blin edited this page Mar 31, 2019 · 4 revisions

RORI v4.0.0

Coverage Status

RORI is a modulable open-source chatterbot platform. The first version was written in 2011 (2.0 in September 2012). I rewrote it in Rust in 2017, and I'm currently migrating the whole communication to use GNU Ring.

A complete RORI chain needs 4 things:

processus

  1. An entry point is a application which get commands from an user and send it to rori_server. For example, a chat where the entry point reads what users says.
  2. An endpoint is a application which performs actions requested by RORI. For example, it can execute a shell command or write something in a chat.
  3. A module is a script activated when a condition is fulfilled and send actions for endpoints to RORI.
  4. The rori_server which get data from entries, call modules, and send data to endpoints.

Why RORI?

I run a lot of chatterbots on multiple services (IRC, Discord, Websites, my computer). Some bots do the exact same thing but run on a different service. The idea is to avoid to rewrite the core of each chatterbot and use the same base. Now, I just have to write an interface to communicate with this core on each services.

This is some examples of what I will do with RORI (as soon as the migration is finished):

  • Ask RORI to launch music on the best device (on my computer, or stream on a discord server for example).
  • Ask RORI to be alarmed at 7:40.
  • Ask RORI to send messages to a friend.
  • Ask RORI to shutdown a device.
  • Send a picture to RORI and ask to store this pict in the best folder.
  • Ask RORI to send me a notification before a rendez-vous.

Acronym

RORI is for RORI On RIng. Where RORI is for Really Obvious Really Intelligent.

How it works

Please, see wiki

Build instructions

make dependencies will install the following packages:

  1. ring-daemon: https://ring.cx for the communication
  2. cargo: https://crates.io/ for rust
  3. sqlite3 for the database
  4. libdbus for the communication between the client and ring-daemon
  5. libncurses for the UI
  6. openssl to generate keys for the API
  7. python > 3.6 for modules.
  8. pip3 and modules: wikipedia

Run your instance

./launch-rori.sh will:

  1. Generate keys for the API
  2. Generate modules table into the database
  3. Then run RORI to generate the config file and the database

config.json looks something like:

{
  "ring_id":"xxxxxxxxxxxxxxxxx",
  "api_listener":"0.0.0.0:1412",
  "cert_path":"keys/api.p12",
  "cert_pass":""
}

Another way is to use docker... this is for now, how I run it:

make docker # build the image
make docker-run

Contribute

Please, feel free to contribute to this project in submitting patches, corrections, opening issues, etc.

If you don't know what you can do, you can look the good-first-issue label, or still creates modules.

For more infos and ideas read CONTRIBUTING.md (this file doesn't exists for now) and CODE_OF_CONDUCT.md.

Clone this wiki locally