ragflow

English | 简体中文 | 日本語 | 한국어 | Bahasa Indonesia

Document | Roadmap | Twitter | Discord | Demo

📕 Table of Contents

💡 What is RAGFlow?
🎮 Demo
📌 Latest Updates
🌟 Key Features
🔎 System Architecture
🎬 Get Started
🔧 Configurations
🔧 Build a docker image without embedding models
🔧 Build a docker image including embedding models
🔨 Launch service from source for development
📚 Documentation
📜 Roadmap
🏄 Community
🙌 Contributing

💡 What is RAGFlow?

RAGFlow is an open-source RAG (Retrieval-Augmented Generation) engine based on deep document understanding. It offers a streamlined RAG workflow for businesses of any scale, combining LLM (Large Language Models) to provide truthful question-answering capabilities, backed by well-founded citations from various complex formatted data.

🎮 Demo

Try our demo at https://demo.ragflow.io.

🔥 Latest Updates

2024-11-01 Adds keyword extraction and related question generation to the parsed chunk to improve the accuracy of retrieval.
2024-09-13 Adds search mode for knowledge base Q&A.
2024-09-09 Adds a medical consultant agent template.
2024-08-22 Support text to SQL statements through RAG.
2024-08-02 Supports GraphRAG inspired by graphrag and mind map.

🎉 Stay Tuned

⭐️ Star our repository to stay up-to-date with exciting new features and improvements! Get instant notifications for new releases! 🌟

🌟 Key Features

🍭 “Quality in, quality out”

Deep document understanding-based knowledge extraction from unstructured data with complicated formats.
Finds “needle in a data haystack” of literally unlimited tokens.

🍱 Template-based chunking

Intelligent and explainable.
Plenty of template options to choose from.

🌱 Grounded citations with reduced hallucinations

Visualization of text chunking to allow human intervention.
Quick view of the key references and traceable citations to support grounded answers.

🍔 Compatibility with heterogeneous data sources

Supports Word, slides, excel, txt, images, scanned copies, structured data, web pages, and more.

🛀 Automated and effortless RAG workflow

Streamlined RAG orchestration catered to both personal and large businesses.
Configurable LLMs as well as embedding models.
Multiple recall paired with fused re-ranking.
Intuitive APIs for seamless integration with business.

🔎 System Architecture

🎬 Get Started

📝 Prerequisites

CPU >= 4 cores
RAM >= 16 GB
Disk >= 50 GB
Docker >= 24.0.0 & Docker Compose >= v2.26.1 > If you have not installed Docker on your local machine (Windows, Mac, or Linux), see Install Docker Engine.

🚀 Start up the server

Ensure vm.max_map_count >= 262144:

To check the value of vm.max_map_count:

   > $ sysctl vm.max_map_count
   > ```
   >
   > Reset `vm.max_map_count` to a value at least 262144 if it is not.
   >
   > ```bash
   > # In this case, we set it to 262144:
   > $ sudo sysctl -w vm.max_map_count=262144
   > ```
   >
   > This change will be reset after a system reboot. To ensure your change remains permanent, add or update the
   `vm.max_map_count` value in **/etc/sysctl.conf** accordingly:
   >
   > ```bash
   > vm.max_map_count=262144
   > ```

2. Clone the repo:

   ```bash
   $ git clone https://github.com/infiniflow/ragflow.git

Build the pre-built Docker images and start up the server:

The command below downloads the dev version Docker image for RAGFlow slim (dev-slim). Note that RAGFlow slim Docker images do not include embedding models or Python libraries and hence are approximately 1GB in size.

   $ cd ragflow/docker
   $ docker compose -f docker-compose.yml up -d

To download a RAGFlow slim Docker image of a specific version, update the RAGFLOW_IMAGE variable in * *docker/.env** to your desired version. For example, RAGFLOW_IMAGE=infiniflow/ragflow:v0.13.0-slim. After making this change, rerun the command above to initiate the download.

To download the dev version of RAGFlow Docker image including embedding models and Python libraries, update the RAGFLOW_IMAGE variable in docker/.env to RAGFLOW_IMAGE=infiniflow/ragflow:dev. After making this change, rerun the command above to initiate the download.

To download a specific version of RAGFlow Docker image including embedding models and Python libraries, update the RAGFLOW_IMAGE variable in docker/.env to your desired version. For example, RAGFLOW_IMAGE=infiniflow/ragflow:v0.13.0. After making this change, rerun the command above to initiate the download.

NOTE: A RAGFlow Docker image that includes embedding models and Python libraries is approximately 9GB in size and may take significantly longer time to load.

Check the server status after having the server up and running:

   $ docker logs -f ragflow-server

The following output confirms a successful launch of the system:


         ____   ___    ______ ______ __               
        / __ \ /   |  / ____// ____// /____  _      __
       / /_/ // /| | / / __ / /_   / // __ \| | /| / /
      / _, _// ___ |/ /_/ // __/  / // /_/ /| |/ |/ / 
     /_/ |_|/_/  |_|\____//_/    /_/ \____/ |__/|__/ 

    * Running on all addresses (0.0.0.0)
    * Running on http://127.0.0.1:9380
    * Running on http://x.x.x.x:9380
    INFO:werkzeug:Press CTRL+C to quit

If you skip this confirmation step and directly log in to RAGFlow, your browser may prompt a network anormal error because, at that moment, your RAGFlow may not be fully initialized.

In your web browser, enter the IP address of your server and log in to RAGFlow. > With the default settings, you only need to enter http://IP_OF_YOUR_MACHINE (sans port number) as the default HTTP serving port 80 can be omitted when using the default configurations.
In service_conf.yaml.template, select the desired LLM factory in user_default_llm and update the API_KEY field with the corresponding API key.

See llm_api_key_setup for more information.

The show is on!

🔧 Configurations

When it comes to system configurations, you will need to manage the following files:

.env: Keeps the fundamental setups for the system, such as SVR_HTTP_PORT, MYSQL_PASSWORD, and MINIO_PASSWORD.
service_conf.yaml.template: Configures the back-end services. The environment variables in this file will be automatically populated when the Docker container starts. Any environment variables set within the Docker container will be available for use, allowing you to customize service behavior based on the deployment environment.
docker-compose.yml: The system relies on docker-compose.yml to start up.

The ./docker/README file provides a detailed description of the environment settings and service configurations which can be used as ${ENV_VARS} in the service_conf.yaml.template file.

To update the default HTTP serving port (80), go to docker-compose.yml and change 80:80 to <YOUR_SERVING_PORT>:80.

Updates to the above configurations require a reboot of all containers to take effect:

> $ docker compose -f docker/docker-compose.yml up -d
> ```

### Switch doc engine from Elasticsearch to Infinity

RAGFlow uses Elasticsearch by default for storing full text and vectors. To switch to [Infinity](https://github.com/infiniflow/infinity/), follow these steps:

1. Stop all running containers:

   ```bash
   $ docker compose -f docker/docker-compose.yml down -v

Set DOC_ENGINE in docker/.env to infinity.
Start the containers:

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

[!WARNING] Switching to Infinity on a Linux/arm64 machine is not yet officially supported.

🔧 Build a Docker image without embedding models

This image is approximately 1 GB in size and relies on external LLM and embedding services.

git clone https://github.com/infiniflow/ragflow.git
cd ragflow/
pip3 install huggingface-hub nltk
python3 download_deps.py
bash build_docker_image.sh slim

🔧 Build a Docker image including embedding models

This image is approximately 9 GB in size. As it includes embedding models, it relies on external LLM services only.

git clone https://github.com/infiniflow/ragflow.git
cd ragflow/
pip3 install huggingface-hub nltk
python3 download_deps.py
bash build_docker_image.sh full

🔨 Launch service from source for development

Install Poetry, or skip this step if it is already installed:
```
curl -sSL https://install.python-poetry.org | python3 -
```

Clone the source code and install Python dependencies:

git clone https://github.com/infiniflow/ragflow.git
cd ragflow/
export POETRY_VIRTUALENVS_CREATE=true POETRY_VIRTUALENVS_IN_PROJECT=true
~/.local/bin/poetry install --sync --no-root --with=full # install RAGFlow dependent python modules

Launch the dependent services (MinIO, Elasticsearch, Redis, and MySQL) using Docker Compose:
```
docker compose -f docker/docker-compose-base.yml up -d
```

Add the following line to /etc/hosts to resolve all hosts specified in docker/.env to 127.0.0.1:

   127.0.0.1       es01 infinity mysql minio redis

In docker/service_conf.yaml.template, update mysql port to 5455 and es port to 1200, as specified in docker/.env.

If you cannot access HuggingFace, set the HF_ENDPOINT environment variable to use a mirror site:

   export HF_ENDPOINT=https://hf-mirror.com

Launch backend service:

source .venv/bin/activate
export PYTHONPATH=$(pwd)
bash docker/launch_backend_service.sh

Install frontend dependencies:
```
cd web
npm install --force
```
Configure frontend to update proxy.target in .umirc.ts to http://127.0.0.1:9380:
Launch frontend service:
```
npm run dev 
```