RAGFlow

RAGFlow implements a multi-strategy document parsing pipeline that uses template-based rules to understand document structure (headers, tables, lists, figures) before chunking. The system supports multiple parsing strategies (layout-aware, semantic, recursive) and applies vision processing (OCR, layout recognition) to extract content with structural awareness. Chunks are generated with preserved context about their document position and semantic relationships, enabling higher-fidelity retrieval than naive text splitting.

RAGFlow implements a multi-tier retrieval system that combines dense vector search (semantic embeddings), sparse BM25 keyword matching, and structured metadata filtering in a single query. Results from multiple recall strategies are fused using learned reranking models that score relevance based on query-document interaction patterns. The system abstracts the document store layer, supporting multiple backends (Elasticsearch, Milvus, Weaviate, PostgreSQL with pgvector) while maintaining consistent retrieval semantics across providers.

RAGFlow exposes a comprehensive REST API covering document management, knowledge base operations, chat/conversation, agent execution, and workflow management. The API supports streaming responses for long-running operations (document parsing, agent reasoning, LLM generation). A Python SDK provides type-safe bindings to the REST API with async support. Both API and SDK handle authentication (API keys, JWT), pagination, error handling, and rate limiting. The API follows REST conventions with proper HTTP status codes and error responses.

RAGFlow uses Celery (or compatible task queue) to distribute long-running operations (document parsing, embedding generation, graph construction) across worker processes. Tasks are queued asynchronously, allowing the API to respond immediately while processing continues in the background. The system tracks task status (pending, running, completed, failed) and provides webhooks or polling endpoints to retrieve results. Failed tasks are automatically retried with exponential backoff. The architecture supports horizontal scaling by adding more worker processes.

RAGFlow implements a comprehensive internationalization system supporting 12+ languages (English, Chinese, Japanese, Korean, Spanish, French, German, Italian, Portuguese, Russian, Vietnamese, Indonesian, Turkish, Arabic). Language strings are externalized to JSON locale files, and the frontend dynamically loads translations based on user language preference. The system supports both UI text and error messages in multiple languages. Language selection is persisted in user preferences and can be changed at runtime.

RAGFlow implements a theming system that allows customization of UI appearance (colors, fonts, spacing) through a centralized theme configuration. The frontend uses CSS variables and theme-aware component styling to support light/dark modes and custom color schemes. Themes are applied globally and can be switched at runtime without page reload. The system supports both built-in themes and custom theme definitions through configuration.

RAGFlow provides a web-based canvas editor that allows users to compose agentic workflows by connecting pre-built components (retrievers, LLM calls, tools, memory) as nodes in a directed acyclic graph (DAG). The canvas engine executes workflows with streaming support, managing state and variable flow between components. Components are dynamically loaded from a registry, supporting both built-in components and custom user-defined components. The DSL (Domain-Specific Language) serializes workflows as JSON, enabling version control and programmatic manipulation.

RAGFlow abstracts LLM provider differences through an LLMBundle pattern that encapsulates provider-specific API calls, error handling, and retry logic. The system supports multiple providers (OpenAI, Anthropic, Ollama, Azure, Hugging Face, etc.) with unified interfaces for chat completion, function calling, and streaming. Tenant-level configuration allows different users/organizations to use different LLM providers without code changes. Error handling includes automatic retries with exponential backoff, rate limit handling, and fallback provider support.

RAGFlow implements a ReAct (Reasoning + Acting) agent loop that iteratively calls an LLM to reason about tasks, invoke tools (retrievers, APIs, code executors), observe results, and refine reasoning. The agent maintains conversation memory (short-term context) and knowledge memory (long-term facts) that persist across interactions. Tool calling is implemented through a schema-based function registry with native bindings for OpenAI and Anthropic function-calling APIs. The agent execution engine handles streaming responses, manages state between iterations, and enforces maximum iteration limits to prevent infinite loops.

RAGFlow implements a multi-tier memory architecture with short-term conversation memory (recent messages and context) and long-term knowledge memory (facts, summaries, embeddings). Conversation memory is stored in a message store and retrieved based on recency and relevance. Knowledge memory uses vector embeddings to store and retrieve learned facts, allowing agents to accumulate and reuse knowledge across conversations. Memory management includes automatic pruning (removing old messages), summarization (compressing long conversations), and deduplication (avoiding redundant fact storage). The memory system is abstracted to support multiple backends (in-memory, Redis, PostgreSQL).

RAGFlow provides a connector framework that abstracts data source integration (databases, APIs, file systems, web crawlers, SaaS platforms) through a unified ingestion pipeline. Connectors handle authentication, pagination, incremental sync, and error recovery. The ingestion pipeline applies document parsing, chunking, and embedding in a configurable sequence. Connectors support scheduled syncs (daily, weekly) and event-driven updates (webhook triggers). The system maintains metadata about data source origin, sync status, and freshness for each ingested document.

RAGFlow implements advanced knowledge graph construction techniques (GraphRAG and RAPTOR) that build hierarchical summaries and entity relationships from documents. GraphRAG extracts entities and relationships from text, constructs a knowledge graph, and generates summaries at multiple levels of abstraction. RAPTOR recursively clusters document chunks, generates summaries for each cluster, and builds a tree structure that enables retrieval at different levels of granularity. These techniques improve retrieval quality by enabling queries to match against summaries at appropriate abstraction levels rather than only raw text chunks.

RAGFlow provides a sandboxed code execution environment that allows agents to execute Python code dynamically within workflows. The sandbox isolates code execution to prevent malicious or buggy code from affecting the main system. Supported operations include data transformation, calculation, API calls, and custom logic. The sandbox includes a restricted set of libraries (pandas, numpy, requests, etc.) and enforces resource limits (execution time, memory). Code execution results are captured and returned to the agent for further reasoning.

RAGFlow implements a multi-tenant architecture where each tenant has isolated data, configuration, and LLM provider settings. Tenants are identified by API key or user session and enforced at the database and API layers. Each tenant maintains separate document stores, knowledge bases, workflows, and memory. Configuration is tenant-specific, including LLM provider choice, model parameters, and feature flags. The system supports both single-tenant (self-hosted) and multi-tenant (SaaS) deployments through configuration.