RAGFlow

RAGFlow implements a multi-strategy document parsing pipeline that uses configurable templates to understand document structure (headers, tables, lists, images) before chunking. The system combines OCR and layout recognition (vision processing) to preserve semantic boundaries, then applies intelligent chunking methods (recursive, sliding window, semantic) that respect document structure rather than naive token splitting. This approach maintains content coherence and enables accurate citation mapping back to source documents.

RAGFlow implements a query processing pipeline that executes both semantic (embedding-based) and keyword (BM25/TF-IDF) retrieval in parallel, then applies learned re-ranking to fuse results. The system supports multiple recall strategies (dense retrieval, sparse retrieval, hybrid) with configurable weights, and includes a reranking layer that scores candidates using cross-encoder models or LLM-based scoring. This multi-tier approach captures both semantic similarity and lexical relevance, improving recall for diverse query types.

RAGFlow includes a Sandbox Code Executor that safely executes Python code within isolated environments, enabling agents to run custom logic, data transformations, and computations without risking the main system. The sandbox enforces resource limits (CPU, memory, execution time) and restricts access to dangerous operations (file system, network). This capability integrates with the tool calling system, allowing agents to execute code as a tool with automatic error handling and output capture.

RAGFlow provides an Admin Service and CLI tools for system-level operations: user and tenant management, model configuration, system health monitoring, database migrations, and backup/restore. The Admin CLI enables operators to configure RAGFlow without accessing the web UI, supporting automation and infrastructure-as-code workflows. The Admin Service exposes endpoints for programmatic system management, enabling integration with external admin dashboards or orchestration platforms.

RAGFlow implements a comprehensive Internationalization (i18n) System that supports 12+ languages (English, Chinese, Japanese, Korean, Spanish, French, German, Italian, Portuguese, Russian, Vietnamese, Indonesian, Turkish, Arabic) through a locale-based translation system. The frontend UI automatically detects user language preferences and loads appropriate translation files. The system is extensible for adding new languages without code changes, using standard i18n patterns (locale files, translation keys, pluralization rules).

RAGFlow includes a Theming System that enables customization of UI appearance through configurable color schemes, typography, and component styles. The system supports light and dark themes with automatic switching based on user preferences or system settings. Theme configuration is stored as JSON/YAML, enabling white-label deployments where SaaS customers can customize the UI to match their brand. The UI Component Architecture uses a design system approach with reusable, themeable components.

RAGFlow provides a web-based Canvas Engine that allows users to compose RAG and agentic workflows by dragging components onto a visual canvas and connecting them with data flow edges. The system includes a DSL (Domain-Specific Language) that translates visual workflows into executable task graphs, with built-in components for document ingestion, retrieval, LLM calling, tool use, and response generation. The Canvas API manages workflow state, variable passing between components, and streaming execution with real-time progress updates.

RAGFlow abstracts LLM provider differences (OpenAI, Anthropic, Ollama, local models) behind a unified LLMBundle interface that handles model selection, API key management, error handling, and retry logic. The system supports tenant-level model configuration, allowing different users or teams to use different LLM providers without code changes. Provider implementations handle format translation (e.g., converting tool schemas to provider-specific formats), streaming response handling, and token counting for cost estimation.

RAGFlow supports tool calling (function use) through a schema-based system that defines tools as JSON schemas, then translates them to provider-specific formats (OpenAI's function_calling, Anthropic's tool_use, etc.). The system includes a Tool Calling and Function Use layer that manages tool definitions, validates LLM-generated tool calls against schemas, and executes tools with error handling. Built-in tools include web search, code execution, and knowledge base retrieval; custom tools can be registered via the API.

RAGFlow implements a ReAct (Reasoning + Acting) loop that orchestrates LLM reasoning, tool selection, execution, and observation cycles. The system manages agent state (current goal, tool history, observations), integrates with the memory system for context persistence, and handles tool execution with error recovery. The Canvas Engine provides visual composition of ReAct workflows, while the Agent API enables programmatic agent definition with custom reasoning strategies.

RAGFlow implements a Memory System with multiple storage types: short-term conversation memory (chat history), long-term knowledge memory (facts extracted from conversations), and session memory (user-specific context). The system provides Memory Management APIs and UI for viewing, editing, and clearing memory, with configurable retention policies and storage backends (database, vector store). Memory is automatically integrated into LLM context during retrieval and generation, enabling personalized responses and knowledge accumulation across conversations.

RAGFlow provides Data Source Connectors that enable ingestion from multiple sources (cloud storage, databases, APIs, web) through a unified pipeline. Each connector handles source-specific authentication, pagination, and format translation, then feeds documents into the parsing and chunking pipeline. The system includes built-in connectors for S3, Azure Blob, Google Drive, Notion, Salesforce, and others, with extensibility for custom sources via the Connector API.

RAGFlow implements advanced features for building hierarchical knowledge representations: GraphRAG constructs entity-relationship graphs from documents, enabling graph-based retrieval and reasoning, while RAPTOR builds recursive abstraction hierarchies that summarize documents at multiple levels of granularity. These features enable retrieval of both detailed facts and high-level summaries, improving context quality for complex queries. The system integrates graph construction with the parsing pipeline, automatically extracting entities and relationships during document processing.

RAGFlow exposes a comprehensive REST API covering dataset management, document ingestion, chat/conversation, agent execution, and memory management. The API includes built-in authentication (API keys, OAuth), tenant isolation for multi-tenant deployments, and rate limiting. A Python SDK wraps the REST API with type hints and convenience methods, enabling programmatic access to all RAGFlow features. The API Architecture supports both synchronous and asynchronous operations, with streaming support for long-running tasks (document processing, agent execution).