[opensourcedex]

RasaGPT is a free, open source ai interaction & interfaces project written in Python and released under MIT. It has 2,464 GitHub stars, 249 forks and 57 open issues, and was last pushed 10 months ago. On this registry it ranks #89 of 135 tracked projects in AI Interaction & Interfaces, with 5 head-to-head comparisons available.

What is RasaGPT?

RasaGPT is an MIT-licensed, headless LLM chatbot platform and reference implementation that combines the Rasa dialogue framework with Langchain and LlamaIndex for indexing, retrieval and context injection, aimed at Python developers who want a working self-hosted starting point for a document-aware Telegram or API chatbot.

What it is

RasaGPT is a headless chatbot platform and boilerplate reference implementation built on top of Rasa and Langchain. It wires together Rasa, FastAPI, Langchain, LlamaIndex, SQLModel, pgvector, ngrok and Telegram so that an LLM can index a corpus, retrieve from it and inject relevant context into a conversation. It lives in the Rasa ecosystem: Rasa is an open-source Python machine learning framework for automating text- and voice-based conversations, with NLU and dialogue management plus connectors such as Slack and Facebook.

The problem it solves is the integration work that otherwise lands on the developer. That covers exposing a proprietary bot endpoint through FastAPI with document upload and a training pipeline, integrating Langchain or LlamaIndex with Rasa, working around library conflicts between LLM libraries and passing metadata through the stack, running Rasa in Docker on macOS, placing a reverse proxy in front of the bot with ngrok, and adding multi-tenancy with sessions and metadata, which Rasa does not natively support. It also replaces Langchain's highly opinionated PGVector class with a custom pgvector schema.

Key capabilities

  • FastAPI endpoint for uploading documents and "training" the bot on an arbitrary corpus indexed through Langchain.
  • Document versioning with automatic "re-training" triggered on upload.
  • Custom asynchronous endpoints and database models defined with FastAPI and SQLModel.
  • Vector search on a custom pgvector schema in place of Langchain's PGVector class.
  • Automatic detection of when human handoff is necessary.
  • Automatic tag generation from user questions and the bot's responses.
  • API documentation served through Swagger and Redoc.

Who uses it and how

  • Python developers who need a document-grounded Telegram bot and do not want to build the Rasa, Langchain and FastAPI glue themselves.
  • Teams that need multiple tenants, sessions and metadata in one deployment, since Rasa has no native multi-tenancy.
  • macOS users running the Dockerized image khalosa/rasa-aarch64:3.5.2; Linux and Windows users swap in rasa/rasa:latest in docker-compose.yml and app/rasa/actions/Dockerfile.
  • Self-hosters exposing a local bot to Telegram or another service through an ngrok reverse proxy.
  • Developers who want their own schema and models rather than accepting Langchain's PGVector conventions.

Getting started

Clone the repository, copy .env-example to .env, add the necessary credentials, then run make install followed by make. Non-macOS users must first change the Rasa image name from khalosa/rasa-aarch64:3.5.2 to rasa/rasa:latest at line 64 of docker-compose.yml and line 1 of app/rasa/actions/Dockerfile.

How it compares

Langchain and LlamaIndex are general-purpose LLM orchestration libraries, and Rasa supplies the dialogue and NLU layer, so RasaGPT is the glue that places both under one FastAPI application with its own PostgreSQL schema and a Telegram front end. Where Langchain ships the PGVector class with fixed conventions, RasaGPT deliberately keeps the vector schema custom so the surrounding models and tenancy fit the host application.

When to use it — and when not to

A self-hoster must operate the whole Docker stack, which means a PostgreSQL database with the pgvector extension, the Rasa server and its action server, provider credentials in the .env file, and ngrok whenever an external reverse proxy is needed. The README states plainly that this is far from production code and is rife with prompt injection and other security vulnerabilities, so anyone serving untrusted users must harden it first or pick a maintained platform instead. Teams expecting a hardened security posture or a stable release cadence should treat it as a reference implementation to learn from rather than a component to deploy unchanged.

project readme (upstream, from github) — read inline

RasaGPT Logo



🏠 Overview

💬 RasaGPT is the first headless LLM chatbot platform built on top of Rasa and Langchain. It is boilerplate and a reference implementation of Rasa and Telegram utilizing an LLM library like Langchain for indexing, retrieval and context injection.




RasaGPT Youtube Video



💬 What is Rasa?

In their own words:

💬 Rasa is an open source (Python) machine learning framework to automate text- and voice-based conversations: NLU, dialogue management, connect to Slack, Facebook, and more - Create chatbots and voice assistants


In my words:

Rasa is a very popular (dare I say de facto?) and easy-enough to use chatbot framework with built in NLU ML pipelines that are obsolete and a conceptual starting point for a reimagined chatbot framework in a world of LLMs.



💁‍♀️ Why RasaGPT?

RasaGPT works out of the box. A lot of the implementing headaches were sorted out so you don’t have to, including:

  • Creating your own proprietary bot end-point using FastAPI, document upload and “training” 'pipeline included
  • How to integrate Langchain/LlamaIndex and Rasa
  • Library conflicts with LLM libraries and passing metadata
  • Dockerized support on MacOS for running Rasa
  • Reverse proxy with chatbots via ngrok
  • Implementing pgvector with your own custom schema instead of using Langchain’s highly opinionated PGVector class
  • Adding multi-tenancy (Rasa doesn't natively support this), sessions and metadata between Rasa and your own backend / application

The backstory is familiar. A friend came to me with a problem. I scoured Google and Github for a decent reference implementation of LLM’s integrated with Rasa but came up empty-handed. I figured this to be a great opportunity to satiate my curiosity and 2 days later I had a proof of concept, and a week later this is what I came up with.


⚠️ Caveat emptor: This is far from production code and rife with prompt injection and general security vulnerabilities. I just hope someone finds this useful 😊



✨ Quick start

Getting started is easy, just make sure you meet the dependencies below.


⚠️⚠️⚠️ ** ATTENTION NON-MACOS USERS: ** If you are using Linux or Windows, you will need to change the image name from khalosa/rasa-aarch64:3.5.2 to rasa/rasa:latest in docker-compose.yml on line #64 and in the actions Dockerfile on line #1 here


# Get the code
git clone https://github.com/paulpierre/RasaGPT.git
cd RasaGPT

## Setup the .env file
cp .env-example .env

# Edit your .env file and add all the necessary credentials
make install

# Type "make" to see more options
make



🔥 Features

Full Application and API

  • LLM “learns” on an arbitrary corpus of data using Langchain
  • Upload documents and “train” all via FastAPI
  • Document versioning and automatic “re-training” implemented on upload
  • Customize your own async end-points and database models via FastAPI and SQLModel
  • Bot determines whether human handoff is necessary
  • Bot generates tags based on user questions and response automatically
  • Full API documentation via Swagger and Redoc included
  • PGAdmin included so you can browser your database
  • Ngrok end-points are automatically generated for you on startup so your bot can always be accessed via https://t.me/yourbotname
  • Embedding similarity search built into Postgres via pgvector and Postgres functions
  • Dummy data included for you to test and experiment
  • Unlimited use cases from help desk, customer support, quiz, e-learning, dungeon and dragons, and more



Rasa integration

  • Built on top of Rasa, the open source gold-standard for chat platforms
  • Supports MacOS M1/M2 via Docker (canonical Rasa image lacks MacOS arch. support)
  • Supports Telegram, easily integrate Slack, Whatsapp, Line, SMS, etc.
  • Setup complex dialog pipelines using NLU models form Huggingface like BERT or libraries/frameworks like Keras, Tensorflow with OpenAI GPT as fallback



Flexibility

  • Extend agentic, memory, etc. capabilities with Langchain
  • Schema supports multi-tenancy, sessions, data storage
  • Customize agent personalities
  • Saves all of chat history and creating embeddings from all interactions future-proofing your retrieval strategy
  • Automatically generate embeddings from knowledge base corpus and client feedback



🧑‍💻 Installing

Requirements


Setup

git clone https://github.com/paulpierre/RasaGPT.git
cd RasaGPT
cp .env-example .env

# Edit your .env file and all the credentials

At any point feel free to just type in make and it will display the list of options, mostly useful for debugging:


Makefile main


Docker-compose

The easiest way to get started is using the Makefile in the root directory. It will install and run all the services for RasaGPT in the correct order.

make install

# This will automatically install and run RasaGPT
# After installation, to run again you can simply run

make run

Local Python Environment

This is useful if you wish to focus on developing on top of the API, a separate Makefile was made for this. This will create a local virtual environment for you.

# Assuming you are already in the RasaGPT directory
cd app/api
make install

# This will automatically install and run RasaGPT
# After installation, to run again you can simply run

make run

Similarly, enter make to see a full list of commands

Makefile API


Installation process

Installation should be automated should look like this:

Installation

👉 Full installation log: https://app.warp.dev/block/vflua6Eue29EPk8EVvW8Kd


The installation process for Docker takes the following steps at a high level

  1. Check to make sure you have .env available
  2. Database is initialized with pgvector
  3. Database models create the database schema
  4. Trains the Rasa model so it is ready to run
  5. Sets up ngrok with Rasa so Telegram has a webhook back to your API server
  6. Sets up the Rasa actions server so Rasa can talk to the RasaGPT API
  7. Database is populated with dummy data via seed.py



☑️ Next steps


💬 Start chatting

You can start chatting with your bot by visiting 👉 https://t.me/yourbotsname

Telegram



👀 View logs

You can view all of the log by visiting 👉 https://localhost:9999/ which will displaying real-time logs of all the docker containers

![Dozzle](https://github.com/paulpierre/RasaGPT/

readme truncated — read the full docs on github

Frequently asked questions

Is RasaGPT free to use?

RasaGPT is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does RasaGPT do?

💬 RasaGPT is the first headless LLM chatbot platform built on top of Rasa and Langchain. Built w/ Rasa, FastAPI, Langchain, LlamaIndex, SQLModel, pgvector, ngr

What is RasaGPT written in?

RasaGPT is primarily written in Python. Its source is publicly available at https://github.com/paulpierre/RasaGPT, and it has 2,464 GitHub stars.