RAGFlow: Open-Source RAG Engine with Agentic Retrieval

What RAGFlow is

RAGFlow is an Apache-2.0 open-source Retrieval-Augmented Generation (RAG) engine from InfiniFlow that combines RAG with agent capabilities. The README pitches it as a context layer for LLMs: a streamlined RAG workflow, a converged context engine and pre-built agent templates that turn complex data into grounded, production-oriented AI systems. Its emphasis is on the ingestion side, summed up in the README's "quality in, quality out" heading: deep document understanding that extracts knowledge from unstructured files with complicated formats before anything reaches the model.

It is a full application rather than a library. You get a web UI, an HTTP API and SDK access, background services for parsing and syncing data, and the storage stack those services need. Teams can use the hosted service at cloud.ragflow.io or self-host it with Docker. The target audience is developers and companies building question answering, search and agent features over their own documents, from personal setups to large businesses.

How it works

Starting with the v1.0.0-rc1 tag, RAGFlow's server is a Go implementation. A single bin/ragflow_server binary runs in one of several modes:

• --migrate runs database migrations and exits.
• --admin starts the Admin service for management and initialization (port 9381).
• --ingestor handles data ingestion and parsing tasks.
• --syncer synchronizes external data sources.
• --api serves the Web UI and SDKs (port 9380), with Nginx in front on ports 80 and 443.

Around that binary sits a set of dependencies started by Docker Compose. The default profile uses Elasticsearch as the document engine (the README notes Infinity as an alternative), MySQL for business metadata (OceanBase is supported through its MySQL-compatible protocol), MinIO for object storage, Kvrocks as a Redis-compatible cache, NATS JetStream as the message queue for ingestion, synchronization, memory and knowledge-compilation messages, and ClickHouse.

Document parsing is handled by DeepDoc, which performs layout analysis, OCR and table structure recognition. In the Go implementation it runs in-process through ONNX Runtime, statically linked into the server binary, so there is no separate DeepDoc service to deploy. In the open-source 1.0 release DeepDoc uses CPU inference. The image does not include embedding models: you connect an LLM, an embedding model and a reranker on the model provider page, or start the optional tei-cpu or tei-gpu profiles for a local text-embeddings-inference service.

Key features

• Deep document understanding: knowledge extraction from unstructured data with complicated formats; the README claims it can find the "needle in a data haystack" across very large token counts.
• Template-based chunking: a choice of chunking templates, designed to be explainable rather than opaque.
• Chunk visualization and grounded citations: you can inspect how text was chunked and intervene manually, and answers come with traceable references to reduce hallucinations.
• Knowledge Compilation: compiles documents or whole datasets into structured artifacts such as wikis, graphs, trees, PageIndex, mind maps, timelines and skills, with configurable models and rules and the ability to regenerate them.
• Agentic retrieval: multi-step retrieval in which the model breaks complex questions down, retrieves, and verifies evidence over several rounds, with Low, Medium, High and Ultra thinking modes to control depth.
• Heterogeneous sources: Word, PowerPoint, Excel, TXT, images, PDFs, scanned copies, structured data and web pages; recent updates added website ingestion through sitemaps and Google BigQuery ingestion with incremental synchronization.
• Configurable retrieval pipeline: pluggable LLMs and embedding models, multiple recall paired with fused re-ranking, and APIs for integrating with business systems.

Getting started

The README recommends starting with 4 CPU cores, 16 GB RAM and 50 GB of free disk, plus Docker 24.0.0 or later and Docker Compose v2.26.1 or later. If you use Elasticsearch, check vm.max_map_count on the Docker host:

sysctl vm.max_map_count

If it is below 262144, raise it (add vm.max_map_count=262144 to /etc/sysctl.conf to keep it after reboot):

sudo sysctl -w vm.max_map_count=262144

Clone the repository, check out the release tag the README points to, and start the services:

git clone https://github.com/infiniflow/ragflow.git
cd ragflow/docker
git checkout v1.0.0-rc2
docker compose -f docker-compose.yml up -d

With the default MySQL configuration, the image entrypoint runs migrations before starting the Admin, Syncer, Ingestor and API services. The RAGFlow container has no Compose healthcheck of its own, so the README uses an HTTP check, and the logs if startup fails:

curl -f http://localhost/api/v1/system/healthz
docker logs --tail 50 ragflow-cpu

After an HTTP 200, open http://IP_OF_YOUR_MACHINE in a browser, sign in, and add an LLM, an embedding model and a reranker (name, service address and API key) on the model provider page. Configuration lives in docker/.env and docker/docker-compose.yml. A launch-from-source path exists for development and needs the Go version in go.mod (currently Go 1.27), Clang 20, LLD 20, CMake 4.0 or later and PCRE2 development files.

Use cases

• Internal knowledge bases where answers must cite the exact passages in policies, contracts or manuals.
• Document-heavy domains with scanned PDFs, tables and slide decks, where layout analysis and OCR determine retrieval quality.
• Context for agents, using RAGFlow's retrieval and pre-built agent templates as the grounding layer behind an assistant.
• Continuously synced data, keeping a dataset current from external sources such as BigQuery tables or a website's sitemap.
• Structured overviews, compiling a document set into a wiki, timeline or mind map for people who need a summary rather than a chat answer.

How it compares

The README does not name competitors. Within the RAG category, the main distinction is packaging: code-first frameworks such as LangChain or LlamaIndex give you building blocks to assemble a pipeline in your own application, while RAGFlow ships an opinionated, deployable system with its own UI, ingestion services, document engine and metadata store. That makes it quicker to stand up a working knowledge base, at the cost of running a multi-container stack and working within its data model. Teams that mostly need retrieval inside an existing service may prefer a library; teams that want a self-hosted RAG product with document parsing included are RAGFlow's natural audience.

Things to know before adopting

• 1.0 is a release candidate: the README points to the v1.0.0-rc2 tag (published October 16, 2026), and the releases page also lists v0.27.3 (October 23, 2026). The Docker guide says tags from v1.0.0-rc1 onward use the Go implementation, so check which line you are deploying and read the release notes before upgrading.
• Platform support: macOS is not currently supported by the Go backend; use a Linux host. Prebuilt images cover Linux x86-64 and ARM64 starting with v1.0.0-rc2.
• Resource footprint: the stack runs several stateful services, and MEM_LIMIT defaults to about 7.52 GiB per container that applies it. Local models need more on top.
• CPU-only parsing: in the open-source 1.0 release DeepDoc layout analysis, OCR and table recognition run on CPU.
• Bring your own models: no embedding models are bundled; budget for LLM, embedding and reranker API keys or self-hosted inference.
• Review the defaults: docker/.env publishes ports for MySQL (3306), MinIO (9000 and 9001), Elasticsearch (1200) and Kvrocks (6379) to the host and holds their passwords; TZ defaults to Asia/Shanghai; keep RAGFLOW_DEV_MODE set to false in production.
• Licence: Apache-2.0, permissive for commercial self-hosting; a separate hosted cloud service is offered by the maintainers.

Project activity

As of October 2026 the repository has about 93,000 stars and 11,100 forks. It was created in December 2023, GitHub reports Go as its primary language, and it is licensed under Apache-2.0. Recent README updates list RAGFlow 1.0.0-rc1 on September 29, 2026, sitemap ingestion on September 10, Knowledge Compilation and agentic RAG on August 19, and BigQuery ingestion on July 2. The project publishes a 2026 roadmap in issue #12241. Source is at github.com/infiniflow/ragflow and documentation at ragflow.io/docs.