All You Need To Know About Just AI Kotlin-Based Conversational Framework

Just AI Conversational Framework or JAICF is a Kotlin-based framework for building conversational applications. The framework can be used for developing applications, such as Alexa or Google Assistant voice skills, telephony assistants or text chatbots for Slack, Facebook and other platforms.

The framework handles dialogue management and provides an architecture to use any third-party NLU, channels and environments. Also, it provides a powerful DSL for dialogues building.

In a blog post, Vitaliy Gorbachev, Just AI’s Solution Owner stated that this framework offers limitless capabilities in building natural language interfaces, and it’s applicable in all kinds of scenarios and use-cases. According to him, a perfect programming language for conversational software, Kotlin brings a context-oriented programming paradigm that is required when it comes to systems where context is crucial.  

The Tech Behind

According to its developers, the main idea of JAICF is to combine multiple platform libraries, NLU engines, persistence layers and servers in the single framework that manages a dialogue state transparently for the developer. 

JAICF does not implement a natural language understanding (NLU) engine itself. Instead, the framework uses third-party libraries and services that implement this functionality and provides a ready to use NLU modules for projects.

JAICF enables developers to create conversational dialogues in a declarative manner using a proprietary DSL. According to its developers, Scenario DSL is a power of JAICF, which allows a developer to write a dialogue scenario of the conversational agent in a declarative manner using Kotlin context-oriented capabilities

Each JAICF conversational agent (chatbot or voice assistant skill) contains at least one scenario that implements a dialogue logic in terms of states, activators, action, reactions and other components.

The framework contains multiple components and all these components are used by JAICF to clue scenarios with persistent layer, channels and NLU engine transparently for the developer. The components include activators, servers, channels, managers, among others.

  • Activators: These are used to activate a state of the dialogue scenario. Every JAICF dialogue scenario contains a set of states that can be activated by activators. 
  • Channels: A Channel is an interface between JAICF dialogue scenario and some text or voice platform. Some of the channels are Amazon Alexa, Google Actions, Slack, etc. JAICF is a multi-channel framework, which means that a single agent can work simultaneously on many channels.
  • Managers: JAICF provides a persistence layer that loads and stores data transparently for the developer using managers. MapDB, Mongo DB, among others are some of the examples of managers in JAICF.
  • Servers: In order to make the agent available for incoming requests from users, there should be some server started that holds a certain JAICF project configuration and proxies requests from the different channels. The framework thus provides ready to use helpers that can be used to easily run such a server and deploy it to any cloud-like Heroku. 

Some of the features of this Kotlin-based framework, JAICF, are mentioned below:

  • Multi-channel Support: JAICF is built on top of native channel libraries; thus, it provides access to the native channel’s features.
  • Extendable Architecture: JAICF uses third-party libraries and services that implement this functionality and provides ready-to-use NLU modules for your projects.
  • Deployment Environment of Your Choice: A developer can connect to any database that maintains the state of dialogue for each user. 
  • Ready-to-Use Dialog State Machine: The engine already has all the basics, such as dialogue manager control flow, state transitions, processing, special features for statistics gathering, bot’s performance, etc.
  • Expressive Syntax: The static typing in JAICF makes complex enterprise-level solutions error-free.
  • Kotlin-based DSL: One can easily build context-aware dialogue scenarios in a declarative style using a proprietary DSL.
  • Autotests: With JAICF, you can autotest your conversational project through already-familiar unit testing.  
  • Scale-up Potential: Being a Kotlin app, JAICF-driven bot can use any Kotlin or Java features and third-party libraries.

How It Helps

As JAICF is a Kotlin framework for conversational context-aware chatbot and voice assistant development, the framework enables any Kotlin developer to build and run enterprise-level cross-platform agents. This means that a single JAICF scenario can work simultaneously over multiple channels like Amazon Alexa, Google Actions, Facebook Messenger and others.

The framework provides a comprehensive open-source architecture mixing all these components into a conversational agent’s framework enabling developers to create a context-aware dialogue and connect it to multiple platforms like Amazon Alexa, Facebook Messenger and more.

Download our Mobile App

Ambika Choudhury
A Technical Journalist who loves writing about Machine Learning and Artificial Intelligence. A lover of music, writing and learning something out of the box.

Subscribe to our newsletter

Join our editors every weekday evening as they steer you through the most significant news of the day.
Your newsletter subscriptions are subject to AIM Privacy Policy and Terms and Conditions.

Our Recent Stories

Our Upcoming Events

3 Ways to Join our Community

Telegram group

Discover special offers, top stories, upcoming events, and more.

Discord Server

Stay Connected with a larger ecosystem of data science and ML Professionals

Subscribe to our Daily newsletter

Get our daily awesome stories & videos in your inbox

6 IDEs Built for Rust

Rust IDEs aid efficient code development by offering features like code completion, syntax highlighting, linting, debugging tools, and code refactoring