Kairon
An open-source agentic AI platform that uses Visual LLM Chaining to let teams build, train, deploy and monitor proactive digital assistants without coding.
CodeQL and Codacy scanning, email verification config, and SECRET_KEY guidance are evidenced, but no least-privilege design or encryption details appear; README advises storing the sender email password in plaintext yaml/env — a clear deduction; telemetry and 'secure script injection' are asserted without implementation detail; no rollback mechanism evidence at all (0); the LICENSE copyright line still reads 'Rasa Technologies GmbH' while maintainers are NimbleWork — an attribution inconsistency.
ModelTestingLogProcessor shows a clear event state machine (ENQUEUED/COMPLETED/FAIL/ABORTED) with explicit error messages ('Event already in progress', 'Daily limit exceeded'), earning 2 for failure messages; Python 3.10 is consistent across README and CI, but the tensorflow-text Windows unavailability is only a side note, so dependency availability scores 1.
README defines two personas (no-code teams / self-hosted teams) with Docker Compose and local dev paths, earning 2 for audience and environment fit; capability boundaries (telemetry trigger conditions, proactive intervention logic) and trigger precision have no code evidence, only marketing claims, scoring 1.
Full Apache-2.0 text in LICENSE.txt earns 3; install notes are detailed (docker, pip, per-field email config) earning 2; NimbleWork and named maintainers earn 2; but no CHANGELOG or version evidence scores 0, badges point to the old repo name rasa-dx and docs are self-described as 'still being fleshed out', so naming stability and examples score 1.
The sample code shows structured, paginated test-log output with error counts, giving medium output usability; the platform layers augmentation, knowledge graphs, and monitoring on Rasa with a plausible value proposition, but this rests on README claims only, so all three score 2 under static review.
Key claims (performance, secure script injection, real-time struggle analytics) have no code or data support, so traceability is poor; only the test-processor code partially corroborates README features; facts and inference are heavily mixed in the README with no citations, so all three score 1.
- README advises storing the sender email password in plaintext in email.yaml or env vars; use a secrets manager in production.
- LICENSE copyright reads 'Rasa Technologies GmbH' while maintainers are NimbleWork; verify legal attribution independently.
- Rollback, capability boundaries, and telemetry data-flow have no doc or code evidence; audit before production use.
- No CHANGELOG or version numbers; upgrade compatibility cannot be assessed statically.
- Publisher is unverified in the curated registry; treat identity as unknown.
What does this agent do, and when should you use it?
Kairon (github.com/digiteinfotech/kairon) is an open-source conversational digital transformation platform maintained by NimbleWork Inc., positioned as an agentic AI platform for building LLM-based digital assistants at scale. It layers a no-code/low-code web interface on top of Rasa Open Source, covering the full lifecycle of a digital assistant from creation, training and testing to deployment and monitoring. Its concrete components include a Rasa-based bot trainer (the trainer-api, run via uvicorn as kairon.api.app.main:app), a question augmentation service (augmentation.paraphrase.server, powered by NLPAug), knowledge graph generation that can automatically produce intents, questions and responses, Kairon Telemetry for real-time struggle analytics, a chat client designer, and an analytics module. The execution model relies on Docker + Docker Compose for deployment, MongoDB (via the MongoEngine ORM) for storage, FastAPI and Uvicorn for the REST API, and SpaCy for NLP. Digital assistants are delivered to websites and SaaS products through secure script injection and can be served in an omni-channel, multi-lingual manner. Overall, it targets teams who want marketing and product staff to maintain conversational assistants directly, rather than a developer-only framework.
Kairon's end-to-end flow works like this: users define conversation data in a web UI, and the platform preprocesses that training data — including question augmentation (a service started with python -m uvicorn augmentation.paraphrase.server:app, based on NLPAug) and knowledge graph generation, which can automatically generate intents, questions and responses. The trainer API (python -m uvicorn kairon.api.app.main:app --host 0.0.0.0 --port 8080) builds and trains bots on the Rasa framework. For deployment, docker-compose up -d inside the docker/ directory starts the full stack; users then open http://localhost/ and can test with the demo account [email protected] / Changeit@123. The output is a digital assistant embedded into a website or SaaS product via secure script injection; once injected, Kairon Telemetry monitors how users interact with the site and proactively intervenes when they hit friction, using real-time struggle analytics. The analytics module provides insights into user interactions, the chat client designer builds custom chat clients, and the integration suite delivers the assistant across channels in multiple languages. The account system supports email verification and password-reset flows configured via email.yaml (or environment variables such as EMAIL_ENABLE and EMAIL_SENDER_*).
- Functional staff on marketing or product teams who need to define how a digital assistant responds to queries without coding, using the hosted interface to create, train, test and deploy.
- Teams that want to self-host the chatbot trainer, running the full Kairon stack in-house via docker-compose.
- Organizations embedding a support assistant into a website or SaaS product that should proactively intervene when users struggle.
- Conversational teams that need to expand training data automatically (question augmentation) or generate intents, questions and responses from knowledge graphs.
- Enterprises that must distribute the same digital assistant across multiple channels and languages.
- Operations teams that want to continuously monitor assistant performance through the analytics module and optimize responses accordingly.
What are this agent's strengths and limitations?
- No-code/low-code web interface lets marketing and product staff — not just engineers — define and train digital assistants; this is the key differentiator over developer-only frameworks like raw Rasa.
- End-to-end lifecycle coverage from creation, training and testing to deployment and monitoring, including Telemetry with real-time struggle analytics that proactively intervenes when users get stuck.
- Question augmentation (NLPAug) and knowledge graph generation automatically produce intents, questions and responses, cutting manual training-data authoring effort.
- One-command Docker Compose deployment with a demo account for immediate validation; assistants embed into any website or SaaS product via secure script injection.
- Ships with an analytics module, chat client designer, and omni-channel multi-lingual integration suite, reducing the need to buy separate components.
- Heavy stack dependencies on Rasa Open Source, MongoDB 4.0+, Python 3.10 and SpaCy; self-hosting means operating a full containerized service set, a nontrivial ops burden.
- A documented Windows development issue: tensorflow-text has no Windows distribution and must be manually removed from requirements.txt, limiting cross-platform development ergonomics.
- Documentation is incomplete — the README states the API documentation is still being fleshed out with only an interim version available, so integration details may be hard to evaluate.
- Assistants are 'tethered' to the platform, meaning deep usage creates coupling with Kairon and migrating elsewhere would require rebuilding.
- LLM capability is only evidenced by a gpt-3.5-turbo topic tag; the README provides no evidence of multi-provider model adapters, so model flexibility is unclear.
How do you install or deploy this agent?
Simplest path — Docker deployment: 1) Install a recent version of Docker and Docker Compose. 2) Edit docker/docker-compose.yml: set the env variable server to the public IP of the machine running the trainer api container (e.g. http://localhost:81); optionally uncomment trackingid and set a Google Analytics tracking id; set SECRET_KEY to a random key generated with openssl rand -hex 32. 3) Run:
cd kairon/docker
docker-compose up -d4) Open http://localhost/ in a browser and test with demo user [email protected] / password Changeit@123.
Development setup: requires Python 3.10 and MongoDB 4.0+. Clone with git clone https://github.com/digiteinfotech/kairon.git, then run setup.bat on Windows (if you get 'No Matching distribution found tensorflow-text', remove that dependency from requirements.txt since no Windows version exists), or chmod 777 ./setup.sh && sh ./setup.sh on Linux.
How do you use this agent?
1) Start the augmentation service: python -m uvicorn augmentation.paraphrase.server:app --host 0.0.0.0. 2) Start the trainer API: python -m uvicorn kairon.api.app.main:app --host 0.0.0.0 --port 8080. 3) Define, train and test digital assistants through the web UI; after a Docker deployment, log in at http://localhost/ (demo: [email protected] / Changeit@123). 4) Deploy assistants to websites via secure script injection. 5) For account email verification/password reset, configure email.yaml or the environment variables (EMAIL_ENABLE, APP_URL, EMAIL_SENDER_EMAIL, EMAIL_SENDER_PASSWORD, EMAIL_SENDER_PORT, EMAIL_SENDER_SERVICE, EMAIL_SENDER_TLS, EMAIL_SENDER_USERID, and the EMAIL_TEMPLATES_* variables). API documentation is at kairon-docs.digite.com.
How does this agent compare with similar options?
Kairon is explicitly built on top of Rasa Open Source: while Rasa focuses on the core chatbot technology, Kairon focuses on preprocessing the data Rasa needs — question augmentation and knowledge graph generation that automatically produce intents, questions and responses — plus post-processing and maintenance such as metrics and follow-up messages, and adds capabilities Rasa does not provide: a no-code UI, Telemetry monitoring, and analytics. Teams comfortable building Rasa projects directly and not needing business-user involvement can use Rasa alone; those wanting a no-code interface and managed operations can adopt Kairon as the layer above it.