RAGFlow

What it is

RAGFlow is an open source Retrieval-Augmented Generation engine from InfiniFlow. Its README says it joins RAG with Agent capabilities to give a language model a context layer. You upload files into a dataset, and RAGFlow cuts them into chunks. A chat then answers from those chunks and cites them. The chunks are visible, so you can read them, add keywords and fix them by hand. A model you choose writes the answers. This listing covers running RAGFlow yourself.

1. You upload files into a dataset
2. DeepDoc reads the layout, text and tables
3. The files are cut into chunks you can review
4. A question pulls the best chunks, ranked
5. The model answers and cites the chunks it used

Who it suits

Developers and teams who want a self-hosted place where documents become a searchable knowledge base with cited answers, and who can run Docker on a Linux server. A product team can call it from its own app through the HTTP API, the Python SDK or MCP. Someone who wants to ask one PDF a question once a month will find it heavy.

Skip self-hosting it if you work on macOS only: the Docker guide says macOS is temporarily not supported by the Go backend. The README also links InfiniFlow’s cloud service at cloud.ragflow.io.

Where to use it

RAGFlow runs where you put it, and the docs name these routes.

• Docker Compose on Linux x86-64 or ARM64, with prebuilt images
• A Docker image you build from the source
• A source build on Ubuntu 24.04 x86_64, for development and debugging
• InfiniFlow’s cloud service, which the README links at cloud.ragflow.io
• Your own code, through the HTTP API and the Python SDK
• Any MCP client, through the endpoint on the API port

The quickstart names these supported formats, among others. The dataset configuration page also parses audio (WAV, MP3, AAC, FLAC, OGG) through an ASR model, email (EML, MSG) and HTML.

How to set it up

Get it saves a zip of Mindket’s setup notes in your downloads folder, with a file for each route and for models. The main route is Docker Compose on a Linux host.

1. Raise vm.max_map_count, then clone. Raise it on the Docker host, then clone the repository.
2. Check out the release tag. Do it in the repository’s docker folder.
3. Change the default passwords. Open docker/.env and change them (ADMIN_DEFAULT_PASSWORD is admin as checked in), then start the stack.
4. Wait for the health check. When it answers, open the machine’s address in a browser and log in.
5. Add an LLM and an embedding model. They go under User settings, Model providers.

sudo sysctl -w vm.max_map_count=262144
git clone https://github.com/infiniflow/ragflow.git
cd ragflow/docker
git checkout v1.0.0-rc3

After you change the passwords in docker/.env, start the stack.

docker compose -f docker-compose.yml up -d

docker ps
curl -f http://localhost/api/v1/system/healthz

The README and the quickstart name v1.0.0-rc3 as the tag. To deploy another version, take a tag from the Releases page and make sure RAGFLOW_IMAGE in docker/.env uses the matching image tag. An HTTP 200 from the health check means RAGFlow is ready. With the default HTTP port 80 you open the address with no port number.

How to use it

The quickstart takes you through four things, in this order.

1. Add models: under User settings, Model providers, make a provider instance, then pick a default Chat model and a default Embedding model.
2. Make a dataset: click Datasets, then Create dataset. Name it, choose the embedding model, and for a first dataset choose General as the Parse mode.
3. Upload and parse: on the dataset’s Files page, click Add file, then Upload file. Switch on Parse on creation, or select the files afterwards and click Run.
4. Chat: click Chat, then Create chat. In Chat setting, pick the parsed dataset and a chat model, save, and ask a question.

Open a parsed file to read its chunks. Hover over a chunk for a quick view, and double click its text to add keywords or edit it. In Retrieval testing, ask a quick question in Test text to check that your configuration works. In the chat window, choose Naive for plain factual questions or Agentic for questions that need several retrieval steps. The chat configuration page says Agentic can take longer than Naive.

Example

You have a folder of product manuals as PDFs. You make a dataset called manuals with the General parse mode and upload the files with Parse on creation on. After parsing, you open one file and read how it was cut into chunks. In Chat, you make a chat, pick manuals and ask a question that one manual answers. The answer shows citations, and you open the chunk each one points to to check it. Your own code can ask the same corpus through MCP. The docs’ sample call looks like this:

curl -sS http://127.0.0.1:9380/api/v1/mcp \
  -H 'Authorization: Bearer <RAGFLOW_API_KEY>' \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"ragflow_retrieval","arguments":{"question":"How do I install Neovim?"}}}'

The reply holds the matching chunks as JSON. You make the key under your avatar, then API.

For newcomers and experts

If you are new. RAG means a model answers from passages found in your own files, not only from what it learned in training. RAGFlow does the finding. It cuts each file into chunks, stores them, and for each question returns the best matches, scored by meaning and by shared words. A dataset is a collection of documents, and a chat can draw on one or several. Choose the embedding model before you parse anything. Start with a few files and the General parse mode, and read the chunks before you trust the answers.

For experts. The docs describe the Go implementation, which the Docker guide says release tags from v1.0.0-rc1 use. One binary, ragflow_server, runs as the API, Admin, Ingestor or Syncer, and --migrate runs the database migrations and exits. DeepDoc layout analysis, OCR and table recognition run inside the server on ONNX Runtime, and the 1.0 release uses CPU inference for them.

The default profile uses Elasticsearch for documents, MySQL for metadata, MinIO for files, Kvrocks as the cache, NATS JetStream for messages and ClickHouse. DOC_ENGINE in docker/.env picks another document engine, and DB_TYPE=oceanbase picks OceanBase for metadata.

Retrieval mixes vector and term similarity. The SDK’s defaults are a similarity threshold of 0.2, a vector weight of 0.3 and top_k 1024. Over MCP, page times page_size must stay inside a fixed window of 512 rerank candidates. Once a dataset holds chunks, a different embedding model must pass a check: the vector dimensions match and the average cosine similarity is at least 0.9. Saving it does not re-embed the old chunks.

MCP works in two ways. POST /api/v1/mcp on the API port 9380 takes each client’s own key and offers three tools: ragflow_retrieval, ragflow_list_datasets and ragflow_list_chats. An optional listener on 127.0.0.1:9382 runs in host mode, where each client authenticates itself, or in self-host mode, where one configured key serves every client.

Good to know

RAGFlow runs on your own server, and a few details are worth reading first.

• License: Apache-2.0. The LICENSE file is the standard text, and its appendix keeps the template line “Copyright [yyyy] [name of copyright owner]”, so it names no holder
• Passwords: the checked-in ADMIN_DEFAULT_PASSWORD is admin, and Docker publishes the Admin port 9381 on the host by default. The docs say to replace the password before first start if other hosts can reach it, and that changing it later does not change an existing account
• Your data: RAGFlow calls the model services you set up, such as the LLM, the embedding model and any rerank, vision, OCR or speech model. If you use them, a chat’s web search provider and the external MCP servers your Agents call also receive the queries you send through them. Your text goes to the model services unless you run them locally, and the docs show Ollama and vLLM for that
• Platforms: macOS is not supported for now, and ARM64 images start with v1.0.0-rc3
• Versions: a development checkout can refuse to start with “Refusing to start: database was migrated by a newer version”. The quickstart says to set RAGFLOW_DEV_MODE=true in .env and run the Compose command again, for local development only, and to leave it false in production
• MCP: in self-host mode every connected client shares one identity, so restrict who can reach it. Keep keys out of command arguments and committed files
• Removal: the docs give no uninstall page, and the README points to the Docker guide for retaining or removing data. Mindket’s notes list the stop and restart commands that guide gives