RAGMeUp's quickstart copies a template the repository does not ship
Generic rag framework to apply the power of LLMs on any given dataset
At a glance
- What is it?
- A four-service RAG stack in Docker Compose, ParadeDB for hybrid vector and keyword search, a Flask retrieval server, an Express API and a React client, with a hybrid mode that moves the Python server onto the host for GPU work. The deployment details are specific and mostly careful, but the first command references a file that is not in the tree.
- Who is it for?
- RAGMeUp fits a team that wants a working RAG application with hybrid vector and keyword retrieval on day one and intends to replace the chunker, vector store or retriever rather than adopt them. It does not fit a Linux deployment that has to stay on unmodified Compose files, since hybrid mode needs an extra host mapping or a hardcoded bridge address, and it does not fit anyone who needs reproducible builds, because the database image tracks a floating tag.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 64 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- SensAI-PT/RAGMeUp680 ★ · +0
| Repository | 2026-09-13 | 2026-11-15 |
|---|---|---|
| SensAI-PT/RAGMeUp | 680 | 680 |
0 Stars in the last 63 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The first command copies a file that is not in the tree
The quickstart is five lines long and one of them cannot work as written:
git clone https://github.com/SensAI-PT/RAGMeUp.git
cd RAGMeUp
cp docker-compose.env.example docker-compose.env
docker compose --env-file docker-compose.env up --build -dThe second step asks you to copy `docker-compose.env.example` into place, and the repository root contains `docker-compose.env` itself but not the example template it tells you to copy from. So the file you are meant to author is absent, while a populated environment file is committed alongside it. The step after that tells you to edit the copy and set at least `POSTGRES_PASSWORD` and `JWT_SECRET`, which is the right instruction and also the reason the defaults in the Compose file are what they are. Read the committed file for the full set of variables and write your own from it rather than expecting the template to appear.
Full Docker is CPU-only, and hybrid mode costs you a compose edit on Linux
The note under the quickstart is unambiguous: the complete Compose setup runs the Python server in CPU-only mode with no GPU or CUDA access inside Docker, so anyone needing accelerated embeddings has to move to the second mode. In hybrid mode, Postgres, the Node API server and the React client stay in containers while the Python RAG server runs standalone on the host, where it can see the GPU. Both Compose files are then passed at once, with the hybrid file as an override. The bill arrives on Linux specifically: `host.docker.internal` resolves on Windows and macOS without help, but on Linux you must add a host-gateway mapping to each service or point `PYTHON_SERVER_URL` at the bridge address directly.
Hybrid mode exposes the database the base file says is hidden
The header comment in the main Compose file is specific about the network posture: four services, being ParadeDB with pgvector and BM25, a Flask and Gunicorn retrieval backend, an Express API for auth, chat, documents and feedback, and an Nginx container serving the React single-page app and reverse-proxying the API. It then states that only the react-client port is exposed to the host and that everything else communicates over an internal Docker network. The hybrid documentation contradicts that, describing ParadeDB as exposed on the host at `localhost:6024` and configurable through `POSTGRES_PORT`, which is exactly what the Python server on the host needs in order to reach it. So the two documents describe two different network shapes, and the one you get depends on which file you start from.
Default credentials appear in three places at once
The Compose service defines its database user, password and database name with a fallback, and all three fall back to the same word. The health check repeats the same fallback twice more, once for the user and once for the database. And the hybrid instructions tell you what `server/.env` should contain, which is a connection string with that identical user and password spelled out. Three separate files therefore agree on a working credential, which is convenient for a first run and exactly what you want to change before anything is reachable. The instructions do ask for a password and a JWT secret before starting, so treat the defaults as a starting point rather than a configuration.
Two mechanisms rewrite the same config values inside Docker
The Compose header carries an important note about configuration, and it is easy to skim past. Your `server/.env` is mounted into the Python container at build time, and Docker-specific values such as `postgres_uri` and `data_directory` are then overridden automatically by the entrypoint script. Two layers are therefore acting on the same keys: what you wrote locally, and what the entrypoint decides the container should use instead. Editing `server/.env` on the host has no effect on the containerized run for those specific values, and the override is invisible unless you read the entrypoint. If you are debugging a connection string that does not match what you configured, that override is the first place to look.
The database image tracks a floating tag
The Postgres service pulls `paradedb/paradedb:latest` with no digest pinned, which is the one reproducibility gap in an otherwise specific configuration. Everything around it is carefully parameterised: the service restarts unless stopped, and the health check runs `pg_isready` every ten seconds with a five-second timeout, five retries and a thirty-second start period, so a slow first boot is not mistaken for a failure. The image reference is not. Combined with the documented habit of running the stack with `--build` on every start, the database can change underneath a deployment between two restarts of the same commands. Data lives in a named volume, so the database contents survive; the engine serving them does not.
An architecture diagram sits in the root that nothing links to
The repository root is small enough to read in one glance, and two of its entries are not mentioned anywhere in the page. `ragmeup.drawio` and its rendered `ragmeup.drawio.svg` are an editable architecture diagram and its export, committed at the top level rather than under documentation, while the README sends anyone asking about architecture to the hosted documentation site instead. The other two directories, `server/` and `ui/`, are the entire source tree: there is no test directory and no workflow configuration. The framework's stated selling point is modularity, that you can bring your own chunkers, vector stores or retrievers, and the battle-testing claim points at the maintainers' own product as the place it has been used in production.
Editorial conclusion
RAGMeUp fits a team that wants a working RAG application with hybrid vector and keyword retrieval on day one and intends to replace the chunker, vector store or retriever rather than adopt them. It does not fit a Linux deployment that has to stay on unmodified Compose files, since hybrid mode needs an extra host mapping or a hardcoded bridge address, and it does not fit anyone who needs reproducible builds, because the database image tracks a floating tag. Before deploying, create the env file by hand since the template is absent, change the default database credentials in the Compose file and the example connection string together, and remember that editing `server/.env` has no effect on the containerized run. The last push is dated 2026-09-12.
Frequently asked questions
How do I start RAGMeUp?
Clone the repository, create `docker-compose.env` from the example template, set at least `POSTGRES_PASSWORD` and `JWT_SECRET`, then run `docker compose --env-file docker-compose.env up --build -d`. The React UI is served on `http://localhost` or the `HOST_PORT` you set.
Can RAGMeUp use a GPU?
Not in the full Compose setup, which runs the Python server CPU-only with no CUDA access inside Docker. Hybrid mode keeps Postgres, the Node server and the React client in containers and runs the Python RAG server standalone on the host for GPU access.
What does RAGMeUp use for retrieval?
ParadeDB, which is Postgres with pgvector and BM25 together, so vector and keyword search run against one database. The Python server reaches it on `localhost:6024` in hybrid mode, configurable through `POSTGRES_PORT`.
Does editing server/.env change the Dockerised RAGMeUp server?
Not for the Docker-specific keys. The file is mounted into the container at build time, and values such as `postgres_uri` and `data_directory` are overridden automatically by the entrypoint script.
What runs in the RAGMeUp Compose stack?
Four services: ParadeDB Postgres with pgvector and BM25, a Flask and Gunicorn retrieval backend, an Express API handling auth, chat, documents and feedback, and an Nginx container serving the React app and reverse-proxying the API.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/sensai-pt-ragmeup)Star history chart for your README
[](https://hysenlabs.com/projects/sensai-pt-ragmeup)Was this useful?