RAGFlow Context Engine
Turn complex data into retrievable, cited LLM context and agent workflows.
Per-dimension scores and reasoning
Evidence shows: The project provides SECURITY.md, but it discloses an unfixed pickle deserialization vulnerability (restricted_loads), which directly violates least privilege because the function allows importing numpy module and executing arbitrary commands. For user confirmation, there is no evidence that user confirmation is required before sensitive operations. For data flow transparency, README describes data ingestion and RAG workflow, but does not clearly explain how data is processed or transmitted. For sensitive data handling, configuration files contain API keys and passwords, but no secure storage mechanism is described. For dependency security, pyproject.toml lists many dependencies and includes CVE-fixing constraints, but the disclosed vulnerability indicates insufficient dependency security. For external effects, the project supports integration with external services (e.g., LLM, cloud storage), but permission controls for these interactions are not described. For rollback, README mentions switching document engines, but no explicit rollback mechanism is provided. For source attribution, the project has clear authors and license, but the publisher is unverified.
Evidence shows: The project has detailed README and configuration docs, self-consistency is good. For dependency availability, pyproject.toml lists many dependencies but no lock file, which may affect reproducibility. For failure messages, README provides some troubleshooting tips but not comprehensive.
Evidence shows: The project targets enterprises and developers, offers multiple deployment methods (Docker, source), audience and scenarios are clear. For capability boundaries, README lists features but no explicit limitations. For trigger precision, no clear trigger conditions are provided. For environment fit, supports multiple OS and architectures, but ARM64 support is limited.
Evidence shows: Information architecture is clear, README has TOC. Install notes are detailed. Naming stability is clear with version numbers. Examples and FAQ are provided in README, but FAQ links to external docs. Known limitations are partially listed (ARM64 not supported). License is Apache-2.0, complete. Versioning changelog is present in README but not detailed. Maintenance responsibility is clear with active community and contribution guidelines.
Evidence shows: Output usability is good with API and web interface. Marginal value is high with RAG and Agent features. Cost benefit is not analyzed; requires significant resources.
Evidence shows: Claim traceability is weak; feature claims lack implementation details. Cross-source corroboration is absent. Fact-inference separation is not clear; README claims are assertive.
- SECURITY.md discloses an unfixed pickle deserialization vulnerability that could lead to remote code execution; avoid using in production or fix promptly.
- Publisher identity is unverified; assess supply chain risks carefully.
- Many dependencies without a lock file may lead to non-reproducible builds.
What does this agent do, and when should you use it?
RAGFlow is an open-source RAG engine that combines retrieval-augmented generation with agent capabilities to form an LLM context layer. It uses DeepDoc-based knowledge extraction for unstructured material and offers template-driven, explainable chunking. The system accepts Word, Slides, Excel, TXT, images, scans, structured data, web pages, and more, then supports retrieval with fused reranking and traceable citations. It can be used through a web interface or self-hosted with Docker Compose; Elasticsearch is the default store for full text and vectors, with an Infinity option. Source development runs a Python backend and web frontend alongside MinIO, Elasticsearch, Redis, and MySQL services.
RAGFlow ingests knowledge from Word, Slides, Excel, TXT, images, scanned copies, structured data, web pages, and other documented sources. DeepDoc performs knowledge extraction from complex unstructured documents. The system chunks content with selectable templates and visualizes chunking so people can intervene. Its retrieval flow uses multiple recall methods and fused reranking to produce answers with key references and traceable citations. The Agent area includes pre-built templates; the README also records an orchestrable ingestion pipeline, MCP support, memory, and a Python/JavaScript code executor component. In self-hosted deployments, docker-compose.yml starts the service, Elasticsearch stores full text and vectors by default, and DOC_ENGINE=infinity selects Infinity instead.
- A knowledge-management team needs a cited question-answering system over internal documents in mixed formats.
- An engineering team wants to self-host a RAG service in Docker while choosing its LLM and embedding-model configuration.
- A support or research operation needs reviewers to inspect chunking and the references behind generated answers.
- A document-heavy organization needs knowledge extraction from scans, images, and complicated unstructured layouts through DeepDoc.
- An agent-workflow developer wants to work over RAG datasets with documented MCP, memory, or code-executor capabilities.
What are this agent's strengths and limitations?
- DeepDoc-based extraction targets complicated formats and unstructured documents rather than plain text alone.
- Chunking visualization, key references, and traceable citations provide a reviewable grounding path for answers.
- Multiple recall methods and fused reranking are combined with configurable LLM and embedding models.
- Docker Compose self-hosting is documented, with a documented switch from Elasticsearch to Infinity.
- The documented minimum self-hosting footprint is 4 CPU cores, 16 GB RAM, and 50 GB disk.
- Pre-built Docker images are x86-only; ARM64 users must build their own image, and Infinity on Linux/arm64 is not officially supported.
- Operators must manage Docker, vm.max_map_count, LLM API keys, and dependent Elasticsearch, MinIO, Redis, and MySQL services.
- The code-executor sandbox requires gVisor, and the README does not document an alternative for that feature.
How do you install or deploy this agent?
Self-hosting requires at least a 4-core CPU, 16 GB RAM, 50 GB disk, Docker >= 24.0.0, Docker Compose >= v2.26.1, and gVisor if the code-executor sandbox is needed. Ensure vm.max_map_count >= 262144, then run: git clone https://github.com/infiniflow/ragflow.git && cd ragflow/docker && git checkout v0.26.4 && docker compose -f docker-compose.yml up -d. When docker logs -f docker-ragflow-cpu-1 shows the service listening on 0.0.0.0, open http://IP_OF_YOUR_MACHINE. In docker/service_conf.yaml.template, select a user_default_llm factory and set its corresponding API_KEY.
How do you use this agent?
After the service has initialized, sign in at http://IP_OF_YOUR_MACHINE. Import source material into a knowledge base, choose an appropriate chunking template, and use the chunking visualization for human review or intervention. Configure the API_KEY for the chosen LLM factory, then use the RAGFlow interface to retrieve answers with references. To use Infinity instead of the default Elasticsearch document engine, stop containers, set DOC_ENGINE=infinity in docker/.env, then start with docker compose -f docker/docker-compose.yml up -d.
How does this agent compare with similar options?
Elasticsearch is the default engine for full text and vectors; setting DOC_ENGINE to infinity switches the document engine to Infinity. The documented switch uses docker compose down -v, which deletes container volumes and existing data.