ragflow

RAGFlow implements a pluggable document parsing pipeline that selects parsing strategies based on document type (PDF, Word, HTML, images, etc.), using specialized handlers for each format. The system includes vision-based OCR and layout recognition for scanned documents, combined with structural parsing for native formats. This ensures high-fidelity extraction of text, tables, and metadata while preserving document structure and semantic relationships.

RAGFlow provides multiple chunking strategies (fixed-size, semantic, layout-aware, and recursive) that can be configured per document type or knowledge base. The system analyzes document structure to identify natural boundaries (sections, paragraphs, tables) and chunks accordingly, rather than blindly splitting at token limits. Semantic chunking uses embeddings to ensure chunks maintain coherent meaning, while layout-aware chunking respects document structure to preserve table integrity and section relationships.

RAGFlow provides connectors for external data sources (databases, APIs, cloud storage, web crawlers) with incremental sync capabilities. The system detects changes in source data using timestamps, checksums, or API-provided change logs, syncing only modified documents to avoid redundant processing. Connectors support scheduling (periodic sync) and manual triggering, with error handling and retry logic for failed syncs.

RAGFlow provides a sandboxed code execution environment enabling agents to execute Python code safely within isolated containers. The sandbox enforces resource limits (CPU, memory, execution time), prevents access to sensitive files or network resources, and captures output for agent observation. This enables agents to perform calculations, data transformations, or custom logic without exposing the host system.

RAGFlow provides a full-featured web interface built with React and TypeScript, supporting document upload, knowledge base management, chat interaction, and workflow visualization. The UI includes a canvas editor for designing agentic workflows, a chat interface with streaming response display, and administrative dashboards for system monitoring. The system supports internationalization (12+ languages) and theming for customization.

RAGFlow exposes a comprehensive REST API covering all major operations (document management, chat, retrieval, workflow execution, memory management) with OpenAPI documentation. A Python SDK provides type-safe bindings for the API, simplifying integration into Python applications. Both API and SDK support async operations, streaming responses, and pagination for large result sets.

RAGFlow implements a hybrid retrieval pipeline combining dense vector search (semantic), sparse BM25 search (lexical), and structured metadata filtering. Retrieved candidates are reranked using learned-to-rank models or cross-encoder networks that score relevance based on query-document interaction. The system supports configurable fusion strategies (RRF, weighted sum) to combine scores from multiple retrieval tiers, enabling both semantic and keyword-based recall with precision reranking.

RAGFlow provides a canvas-based workflow engine that orchestrates multi-step agentic processes using a ReAct (Reasoning + Acting) loop pattern. Agents decompose tasks into reasoning steps, select tools from a registry, execute them, and observe results in an iterative cycle. The system includes built-in tools (retrieval, calculation, code execution) and supports custom tool registration via a schema-based function calling interface compatible with OpenAI, Anthropic, and other LLM providers.

RAGFlow implements a tiered memory architecture supporting short-term conversation history, long-term knowledge persistence, and user/session-specific memory scopes. The system stores conversation turns with embeddings for semantic recall, maintains a knowledge graph of extracted facts and relationships, and supports memory operations (add, retrieve, update, forget) via API. Memory can be persisted to multiple backends (PostgreSQL, vector databases) and retrieved using hybrid search to augment LLM context.

RAGFlow implements advanced knowledge extraction techniques including GraphRAG (building entity-relationship graphs from documents) and RAPTOR (recursive abstraction and processing for tree-organized retrieval). These methods extract entities, relationships, and hierarchical summaries from documents, enabling retrieval at multiple abstraction levels. The system supports both graph-based and tree-based retrieval, allowing queries to match at entity, relationship, or summary levels depending on information need.

RAGFlow abstracts LLM provider differences through a unified LLMBundle interface that supports OpenAI, Anthropic, Ollama, DeepSeek, and other providers. The system handles provider-specific API differences (function calling schemas, streaming formats, error codes) transparently, enabling model switching without code changes. Built-in retry logic, timeout handling, and fallback strategies ensure resilience across provider outages or rate limits.

RAGFlow tracks document provenance throughout the retrieval and generation pipeline, maintaining position metadata (document ID, chunk ID, page number, character offset) for all retrieved content. When generating responses, the system maps LLM output back to source chunks and generates citations with confidence scores based on retrieval relevance and semantic similarity. Citations include document metadata, position information, and optional direct quotes for verification.

RAGFlow implements tenant-scoped knowledge bases with role-based access control (RBAC) and data isolation at the storage layer. Each tenant has isolated document collections, embeddings, and retrieval indices, with API-level access control enforcing permissions. The system supports tenant-specific LLM model configurations, enabling different teams to use different models or providers while sharing infrastructure.

RAGFlow supports streaming LLM responses with token-level control, enabling real-time response delivery and user cancellation. The system streams tokens from the LLM provider while maintaining retrieval context and citation information, allowing clients to display responses incrementally. Streaming can be cancelled mid-generation, and the system gracefully handles provider disconnections or timeouts.