lang: vi slug: ragflow title: ‘RAGFlow: Deploy a Production-Ready RAG Engine with 80K+ Stars’ description: ‘RAGFlow is an open-source retrieval-augmented generation (RAG) engine with deep document understanding and built-in agent capabilities. Compatible with Ollama, OpenAI, Qdrant, Elasticsearch, and Redis. Covers Docker deployment, document ingestion, retrieval tuning, and production hardening.’ tags: [“container”, “devops”, “docker”, “knowledge-base”, “llm”, “open-source”, “rag”, “retrieval”] date: 2026-05-19 00:00:00+08:00 lastmod: 2026-05-19 00:00:00+08:00 tech_stack: [] application_domain: Llm Frameworks source_version: ’' licensing_model: Open Source license_type: Apache-2.0 file_size: ’' file_md5: ’' download_url: ’' backup_url: ’' github_repo: ‘https://github.com/infiniflow/ragflow' last_maintained: ‘2026-05-19’ draft: false categories: [’llm-frameworks’] aliases:- /posts/ragflow/ faqs:

• q: ‘What is RAGFlow and what makes it different from other RAG frameworks?’ a: ‘RAGFlow is an open-source retrieval-augmented generation engine (80,000+ GitHub stars, Apache-2.0) that combines deep document understanding with LLM-powered agents. Unlike generic RAG libraries that rely on simple text splitting, its DeepDoc engine performs layout analysis on PDFs, spreadsheets, slides, and scanned documents to preserve tables, images, and headers during ingestion.’
• q: ‘What are the minimum hardware requirements to run RAGFlow?’ a: ‘The minimum is 4 CPU cores (x86_64), 16 GB RAM, and 50 GB SSD, with Docker 24.0.0+ and Docker Compose v2.26.1+. For production serving 50+ users, use 8+ vCPU, 32+ GB RAM, and 200+ GB NVMe; add a GPU with 8+ GB VRAM if parsing large scanned PDFs with OCR.’
• q: ‘Can RAGFlow run entirely with local LLMs for privacy?’ a: ‘Yes. RAGFlow integrates with Ollama, vLLM, Xinference, and LocalAI for fully local inference. Configure the provider’’s base URL in service_conf.yaml.template, and for embeddings pull a model like nomic-embed-text through Ollama and set it in the web UI under Model Providers. When self-hosted, documents stay on your infrastructure and are not sent to external services unless you configure a cloud LLM.’
• q: ‘Which document formats does RAGFlow support?’ a: ‘RAGFlow supports Word (DOC, DOCX), PowerPoint (PPT, PPTX), Excel (XLS, XLSX), PDF, TXT, Markdown, images (PNG, JPG, BMP, TIFF), scanned copies, HTML, and CSV. It can also import data from Confluence, Notion, Google Drive, Discord, and S3.’
• q: ‘What backend services does RAGFlow need, and is it lightweight?’ a: ‘RAGFlow is not a single-binary tool. It requires multiple backend services: Elasticsearch or Infinity for vector and full-text indexing, MinIO for object storage, MySQL for metadata, and Redis for caching and task queuing. Because of this, it needs at least 16 GB RAM; for simple side projects, lighter alternatives like LightRAG may be more appropriate.’

featureImage: /images/articles/ragflow-deploy-a-production-ready-rag-en.png —{{< resource-info >}} PageIndex：29K⭐Vectorless RAG System • JuiceFS (14K⭐): The Distributed POSIX File System That Turns

sysctl vm.max_map_count

Set to at least 262144 (required by Elasticsearch) #

sudo sysctl -w vm.max_map_count=262144

Persist across reboots #

echo “vm.max_map_count=262144” | sudo tee -a /etc/sysctl.conf ### Step 1: Clone the Repository bas h git clone https://github.com/infiniflow/ragflow.git cd ragflow/docker git checkout -f v0.25.4 ### Step 2: Configure Environment Variables bas h

Edit the environment file #

cp .env .env.backup nano .env

e
y
variables to se```
bas
h
git clone https://github.com/infiniflow/ragflow.git
cd ragflow/docker
git checkout -f v0.25.4
```ecu
r
e
_mysql_password
MINIO_PASSWORD=your_secure_minio_password
REDIS_PASSWORD=your_secure_redis_password# Choose your document engine: elastics```
bas
h
# Edit the environment file
cp .env .env.backup
nano .env
```t
h
Docker Compose```
bas
h
# CPU-only deployment
docker compose -f docker-compose.yml u```
bas
h
# docker/.env
RAGFLOW_IMAGE=infiniflow/ragflow:v0.25.4
SVR_HTTP_PORT=80
MYSQL_PASSWORD=your_secure_mysql_password
MINIO_PASSWORD=your_secure_minio_password
REDIS_PASSWORD=your_secure_redis_password

# Choose your document engine: elasticsearch or infinity
DOC_ENGINE=elasticsearch
```____
__
#    / __ \ /   |  / ____// ____// /____  _      __
#   / /_/ // /| | / / __ / /_   / // __ \| | /| / /
#  / _, _// ___ |/ /_/ // __/  / // /_/ /| |/ |/ /
# /_/ |_|/_/  |_|\____//_/    /_/ \____/ |__/|__/
#  * Running on all addresses (0.0.0.0)
```### Step 4: Configure Your LLM ProviderEdit `service_conf.yaml.temp```
bas
h
# CPU-only deployment
docker compose -f docker-compose.yml up -d

# GPU-accelerated document parsing (NVIDIA)
# sed -i '1i DEVICE=gpu' .env
# docker compose -f docker-compose.yml up -d
```od
e
l
: gpt-4.1-mini
```Suppor
t
e
d
LLM providers include OpenAI, Anthropic, DeepSeek, Gemini, Azure OpenAI, Bedrock, and local models via Ollama or vLLM. Restart the containers after configuration changes:```
bas
h
d```
bas
h
# Watch the logs until you see the success message
docker logs -f ragflow-server

# Expected output:
#     ____   ___    ______ ______ __
#    / __ \ /   |  / ____// ____// /____  _      __
#   / /_/ // /| | / / __ / /_   / // __ \| | /| / /
#  / _, _// ___ |/ /_/ // __/  / // /_/ /| |/ |/ /
# /_/ |_|/_/  |_|\____//_/    /_/ \____/ |__/|__/
#  * Running on all addresses (0.0.0.0)
```Popu
l
a
r
Tools### Ollama (Local LLMs)For air-gapped or privacy-sensitive deployments, connect RAGFlow to Ollama:```
yam
l
# docker/service_conf.yaml.template
user_default_llm:
  factory: Ollama
  api_key: ""
  base_url: http://host.docker.internal:11434
  default_model: llama3.2
```P
u
l
l
models in Ollama before using them:```
bas
h
ollama pull llama3.2
ollama pull nomic-embed-text
```Config
u
r
e
the embedding model in the RAGFlow web UI under **Settings > Model Providers**.### Ope```
yam
l
# docker/service_conf.yaml.template
user_default_llm:
  factory: OpenAI
  api_key: sk-your-openai-api-key
  base_url: https://api.openai.com/v1
  default_model: gpt-4.1-mini
```l
e
substitution to avoid hardcoding secrets:```
bas
h
# In .env
OPENAI_API_KEY=sk-your-key
```### Elasticsearch to Infinity MigrationInfinity is RAGFlow's converged context engine optimized for large-scale deployments. To switch:```
bas
h
# 1. Stop all containers and clear volumes
docker compose -f docker-compose.yml down -v# 2. Update .env
sed -i 's/DOC```
bas
h
docker compose -f docker-compose.yml down
docker compose -f docker-compose.yml up -d
```y
m
l
up -d
```> **Warning:** This wipes existing data. Back up your datasets before migrating.### Redis as External CacheFor production deployments, use an external Redis cluster:```
yam
l
# docker-c```
Email: admin@ragflow.io
Password: (set during first login)
```    command: redis-server --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis_data:/data
    deploy:
      resources:
        limits:
          memory: 2G
```### Qdrant as Alternative Vector StoreWhile RAGFlow uses Elasticsearch or Infinity natively, you can integrate Qdrant via the Python ```
yam
l
# docker/service_conf.yaml.template
user_default_llm:
  factory: Ollama
  api_key: ""
  base_url: http://host.docker.internal:11434
  default_model: llama3.2
```y
="your-key", base_url="http://localhost:9380")
qdrant = QdrantClient(url="http://localhost:6333")# Custom hybrid retrieval combining RAGFlow chunks with Qdrant vectors
chunks = ragflow.retrieve(dataset_i```
bas
h
ollama pull llama3.2
ollama pull nomic-embed-text
```r
c
h
(collection="financial_reports", vector=query_embedding, limit=5)
```## Benchmarks / Real-World Use Cases### Retrieval Quality BenchmarksA 2026 benchmark by AI M```
yam
l
user_default_llm:
  factory: OpenAI
  api_key: ${OPENAI_API_KEY}
  base_url: https://api.openai.com/v1
  default_model: gpt-4.1-mini
```| LlamaIndex | Haystack | LangChain RAG |
|--------|---------|------------|----------|---------------|
| Answer Accuracy | 97% | 94% | 95% | 91% |
| Avg. Retrieval Latency | 420ms | 380ms | 450ms | 510ms |
```b
a
s
h
# In .env
OPENAI_API_KEY=sk-your-key
``` 1,570 | 2,400 |
| Framework Overhead | 8ms | 6ms | 5.9ms | 10ms |
| Citation Grounding Score | 96% | 88% | 90% | 82% |RAGFlow leads in accuracy and citation grounding due to Deep```
bas
h
# 1. Stop all containers and clear volumes
docker compose -f docker-compose.yml down -v

# 2. Update .env
sed -i 's/DOC_ENGINE=elasticsearch/DOC_ENGINE=infinity/' .env

# 3. Restart
docker compose -f docker-compose.yml up -d
```-------|-------------------|------------|----------|
| PDF with tables | Full structure preserved | Flat text | Flat text |
| Scanned PDF (OCR) | Native support | Requires extension | Requires extension |
| PowerPoint slides | Slide-aware chunking | Per-slide | Per-slide |
| Excel spreadsheets | Cell-level extraction | CSV conversion | CSV conversion |
| Multi-language docs | Cross-language query |```
yam
l
# docker-compose.yml (excerpt)
services:
  redis:
    image: redis:7-alpine
    command: redis-server --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis_data:/data
    deploy:
      resources:
        limits:
          memory: 2G
```80
(DigitalOcean) |
| Department (100 users) | 100 | 100,000 | 8 vCPU, 32 GB RAM | ~$200 (DigitalOcean) |
| Enterprise (1000+ users) | 1000+ | 1M+ | 16 vCPU, 64 GB RAM + GPU | ~$800+ (cloud) |> Looking for a reliable cloud host for RAGFlow? Deploy on DigitalOcean
 with one-click Docker setup, or use HTStack
 for managed ```
pytho
n
from qdrant_client import QdrantClient
from ragflow_sdk import RAGFlow

# Connect to both systems
ragflow = RAGFlow(api_key="your-key", base_url="http://localhost:9380")
qdrant = QdrantClient(url="http://localhost:6333")

# Custom hybrid retrieval combining RAGFlow chunks with Qdrant vectors
chunks = ragflow.retrieve(dataset_id="ds_123", query="annual revenue 2025")
vectors = qdrant.search(collection="financial_reports", vector=query_embedding, limit=5)
```      proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 300s;
    }
}
```### Enable GraphRAG for Multi-Hop ReasoningGraphRAG extracts knowledge graphs from documents, enabling cross-document reasoning:```
pytho
n
# Via the RAGFlow web UI or API
POST /api/datasets/{dataset_id}/chunks/graph
{
  "method": "ligh",
  "entity_types": ["PERSON", "ORGANIZATION", "PRODUCT", "EVENT"],
  "max_workers": 4
}
```Graph
R
A
G
is especially effective for legal documents, research papers, and financial reports where relationships between entities span multiple pages.### Configure the Sandbox (Code Execution)RAGFlow's agent can execute Python and JavaScript code in a sandboxed environment. This requires gVisor:```
bas
h
# Install gVisor (required for sandbox)
sudo apt-get install -y runsc# Enable in docker-compose.yml
services:
  ragflow:
    environment:
      - ENABLE_SANDBOX=true
    devices:
      - /dev/kvm
```### Monitoring with Prometheus```
yam
l
# Add to docker-compose.yml
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    ports:
      - "9090:9090"  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
```K
e
y
metrics to monitor:```
yam
l
# prometheus.yml
scrape_configs:
  - job_name: 'ragflow'
    static_configs:
      - targets: ['ragflow-server:9380']
    metrics_path: /metrics
```### Backup Strategy```
bas
h
#!/bin/bash
# /opt/ragflow/backup.shBACKUP_DIR="/backups/ragflow/$(date +%Y%m%d)"
mkdir -p $BACKUP_DIR# Backup MySQL
docker exec ragflow-mysql mysqldump -u root -p$MYSQL_PASSWORD ragflow > $BACKUP_DIR/mysql.sql# Backup Elasticsearch indices
docker exec ragflow-es curl -sX POST "localhost:9200/_snapshot/backup" \
  -H 'Content-Type: application/json' \
  -d'{"indices": "ragflow_*"}'# Backup MinIO objects
docker exec ragflow-minio mc mirror /data $BACKUP_DIR/minio# Sync to remote storage
rclone sync $BACKUP_DIR s3:my-backup-bucket/ragflow/
```## Comparison with Alternatives| Feature | RAGFlow | LlamaIndex | Haystack | LangChain RAG |
|---------|---------|------------|----------|------------
---|
| **GitHub Stars** | 82,565 | 49,500 | 25,300 | 105,000 |
| **License** | Apache-2.0 | MIT | Apache-2.0 | MIT |
| **Deep Document Parsing** | De```
ngin
x
# /etc/nginx/sites-available/ragflow
server {
    listen 443 ssl http2;
    server_name ragflow.yourcompany.com;

    ssl_certificate /etc/letsencrypt/live/ragflow.yourcompany.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/ragflow.yourcompany.com/privkey.pem;

    location / {
        proxy_pass http://localhost:80;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 300s;
    }
}
```o
n
package | Python package | Python package |
| **MCP Protocol Support** | Yes | No | No | No |
| **REST API** | Full API | Requires building | Requires building | Requires building |
| **Enterprise SSO** | Yes | Cloud only | Cloud only | Cloud only |### When to Choose What- **RAGFlow**: You need a complete self-hosted RAG platform with deep document understanding, a visual UI, and built-in agents. Best for enterprises handling complex documents (PDFs, scans, spreadsheets) that want full data control.
- **LlamaIndex**: You are building a custom Python application with specific indexing needs and prefer a library over a platform. Best for developers who need maximum flexibility and don't mind building their o```
pytho
n
# Via the RAGFlow web UI or API
POST /api/datasets/{dataset_id}/chunks/graph
{
  "method": "ligh",
  "entity_types": ["PERSON", "ORGANIZATION", "PRODUCT", "EVENT"],
  "max_workers": 4
}
```n
g
.
- **LangChain RAG**: You want the largest ecosystem of integrations and don't mind assembling components yourself. Best for rapid prototyping and startups that need to iterate quickly.## Limitations / Honest Assessment**Not a lightweight tool.** RAGFlow requires a minimum of 16 GB RAM and multiple backend services (Elasticsearch, MySQL, Redis, MinIO). This is not a single-binary deployment. If you need a simple RAG setup for a side project, consider lighter alternatives like LightRA```
bas
h
# Install gVisor (required for sandbox)
sudo apt-get install -y runsc

# Enable in docker-compose.yml
services:
  ragflow:
    environment:
      - ENABLE_SANDBOX=true
    devices:
      - /dev/kvm
```t
i
m
e
to deployment.**Learning curve for advanced features.** The visual UI covers 80% of use cases, but enabling GraphRAG, configuring custom embedding pipelines, or building agents requires reading the documentation carefully.**No```
yam
l
# Add to docker-compose.yml
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
```t
h
e
r
download embedding models at runtime or connect to external embedding services.## Frequently Asked Questions### What hardware do I need for a production RAGFlow deployment?For a production deployment serving 50+ users, use a server with at least 8 vCPU cores, 32 GB RAM, and 200 GB NVMe SSD. If you are parsing large scanned PDFs with OCR, add a GPU with at least 8 GB ```
yam
l
# prometheus.yml
scrape_configs:
  - job_name: 'ragflow'
    static_configs:
      - targets: ['ragflow-server:9380']
    metrics_path: /metrics
``` LLMs only?Yes. RAGFlow integrates with Ollama, vLLM, Xinference, and LocalAI. Configure the LLM provider in `service_conf.yaml.template` with the base URL of your local```
bas
h
#!/bin/bash
# /opt/ragflow/backup.sh

BACKUP_DIR="/backups/ragflow/$(date +%Y%m%d)"
mkdir -p $BACKUP_DIR

# Backup MySQL
docker exec ragflow-mysql mysqldump -u root -p$MYSQL_PASSWORD ragflow > $BACKUP_DIR/mysql.sql

# Backup Elasticsearch indices
docker exec ragflow-es curl -sX POST "localhost:9200/_snapshot/backup" \
  -H 'Content-Type: application/json' \
  -d'{"indices": "ragflow_*"}'

# Backup MinIO objects
docker exec ragflow-minio mc mirror /data $BACKUP_DIR/minio

# Sync to remote storage
rclone sync $BACKUP_DIR s3:my-backup-bucket/ragflow/
```e
n
using RAGFlow?When self-hosted, all data remains on your infrastructure. Documents are stored in MinIO, vectors in Elasticsearch/Infinity, and metadata in MySQL — all within your network. RAGFlow does not send documents to external services unless you configure a cloud LLM provider. For maximum privacy, use local LLMs and embedding models.### How do I upgrade RAGFlow to a new version?First, back up your MySQL database and Elasticsearch indices. Then pull the new Docker image, update the `RAGFLOW_IMAGE` variable in `.env`, and restart the containers. Always check the release notes for breaking changes between versions.```
bas
h
cd ragflow/docker
git fetch --tags
git checkout -f v0.25.4
# Update .env with new image tag
docker compose -f docker-compose.yml down
docker compose -f docker-compose.yml pull
docker compose -f docker-compose.yml up -d
```### Can I integrate RAGFlow into my existing application?Yes. RAGFlow exposes a full REST API and provides Python and JavaScript SDKs. You can create datasets, upload documents, start chat sessions, and retrieve answers programmatically. The API documentation is available at `/api/docs` on your RAGFlow instance.### What document formats does RAGFlow support?RAGFlow supports Word (DOC, DOCX), PowerPoint (PPT, PPTX), Excel (XLS, XLSX), PDF, TXT, Markdown, images (PNG, JPG, BMP, TIFF), scanned copies, HTML, and CSV. It also supports importing data from Confluence, Notion, Google Drive, Discord, and S3.### Does RAGFlow support multi-tenancy?RAGFlow supports multiple users and datasets with role-based access control within a single instance. For true multi-tenancy (isolated tenants with separate data), you currently need to run separate RAGFlow instances or implement tenant filtering at the application layer.### Self-Hosting NoteRunning this on your own VPS? Try DigitalOcean with $200 free credit
 — enough for 2 months of moderate self-hosting to test the setup risk-free. Best for low-medium traffic; scale to dedicated when you outgrow it.## ConclusionRAGFlow stands out as the only open-source RAG platform that combines deep document understanding, a production-ready web UI, and built-in agent capabilities in a single deployable system. With 82,565 GitHub stars and an active development cycle, it has proven its value for teams that need more than a basic text-splitting RAG pipeline. The Docker-based deployment takes under 30 minutes, and the hybrid search architecture delivers measurably better retrieval quality than framework-only alternatives.**Your next steps:**1. Clone the repository and deploy RAGFlow on your server using Docker Compose
2. Upload a complex PDF with tables and verify the parsing quality in the web UI
3. Configure your preferred LLM provider (OpenAI, DeepSeek, or Ollama)
4. Set up HTTPS and automated backups for production use
5. Join the community for support and feature updatesJoin our [Telegram developer community](https://t.me/dibi8opensource) for deployment tips and production RAG discussions. Share your RAGFlow setup — we feature the best configurations in our weekly newsletter.*Some links in this article are affiliate links. We may earn a commission if you purchase hosting services through these links. This does not affect our editorial recommendations.*







## Recommended Hosting & InfrastructureBefore you deploy any of the tools above into production, you'll need solid infrastructure. Two options dibi8 actually uses and recommends:- **DigitalOcean
** — $200 free credit for 60 days across 14+ global regions. The default option for indie devs running open-source AI tools.
- **HTStack
** — Hong Kong VPS with low-latency access from mainland China. This is the same IDC that hosts dibi8.com — battle-tested in production.*Affiliate links — they don't cost you extra and they help keep dibi8.com running.*## Sources & Further Reading- [RAGFlow GitHub Repository](https://github.com/infiniflow/ragflow)
- [RAGFlow Official Documentation](https://ragflow.io/docs/dev/)
- [RAGFlow Quickstart Guide](https://ragflow.io/docs/dev/)
- [RAGFlow Docker Deployment README](https://github.com/infiniflow/ragflow/blob/main/docker/README.md)
- [DeepDoc Document Understanding](https://github.com/infiniflow/ragflow/tree/main/deepdoc)
- [RAGFlow REST API Reference](https://ragflow.io/docs/dev/category/references)
- [RAGFlow vs Other RAG Frameworks Benchmark](https://aimultiple.com/rag-frameworks)
- [LlamaIndex GitHub Repository](https://github.com/run-llama/llama_index)
- [Haystack GitHub Repository](https://github.com/deepset-ai/haystack)
- [Best Open Source RAG Frameworks 2026 Comparison](https://www.firecrawl.dev/blog/best-open-source-rag-frameworks)
- [RAGFlow Architecture Explained](https://milvus.io/ai-quick-reference/what-is-ragflow-and-how-does-it-work)
- [RAGFlow Production Deployment on VPS](https://zhujibaike.com/2497.html)
```b
a
s
h
cd ragflow/docker
git fetch --tags
git checkout -f v0.25.4
# Update .env with new image tag
docker compose -f docker-compose.yml down
docker compose -f docker-compose.yml pull
docker compose -f docker-compose.yml up -d