RAG-Anything

Processes heterogeneous document types (PDFs, Office documents, images, text files) through a pluggable parser architecture supporting multiple backends (MinerU, Docling) with format-specific optimization. The system implements a parse caching layer to avoid redundant processing and maintains document status tracking across the pipeline, enabling resumable and incremental document ingestion at scale.

Decomposes multimodal content into specialized processors that extract semantic meaning from images (via vision models), tables (via structure-aware parsing), and mathematical equations (via LaTeX/MathML extraction). The architecture uses a ProcessorMixin pattern where each modality has a dedicated processor class that can be extended or replaced, enabling custom modal processor development without modifying core pipeline logic.

Enables programmatic document ingestion by accepting pre-structured content lists (bypassing file parsing) through insert_content_list() method. This capability allows users to integrate RAG-Anything with custom data sources (databases, APIs, streaming sources) by converting their data to content list format and inserting directly into the pipeline. Content lists skip the parsing stage and proceed directly to modal processing and indexing.

Implements parse caching that stores parsed document representations to avoid redundant parsing on subsequent runs, and incremental indexing that only processes new or modified documents. The caching system tracks document modification times and content hashes to detect changes, enabling efficient re-indexing of large document collections. Combined with batch processing status tracking, this enables fast iteration during development and efficient updates in production.

Orchestrates document ingestion through a five-stage pipeline (parsing → modal processing → context extraction → knowledge graph construction → storage) built on top of LightRAG. Each stage is implemented as a method in ProcessorMixin, with intermediate outputs cached and document status tracked, enabling resumable processing and fine-grained error handling. The pipeline integrates LightRAG's knowledge graph construction to automatically extract entities and relationships across all modalities.

Implements a BatchMixin that processes multiple documents concurrently while maintaining per-document status tracking (processed, failed, pending) and enabling selective retry of failed documents. The batch processor integrates with the parse caching system to skip already-processed documents and provides detailed error logs for debugging processing failures across large document collections.

Executes three query modes (text-only, multimodal, VLM-enhanced) through a QueryMixin that retrieves relevant documents and modal content based on query intent. Text queries use semantic search over embeddings; multimodal queries retrieve both text and images; VLM-enhanced queries pass retrieved images to a vision language model for deeper semantic understanding. The query system integrates with LightRAG's knowledge graph to support entity and relationship queries.

Abstracts storage operations through a configurable backend system that supports multiple persistence targets (local file system, vector databases, graph databases) without changing application code. The storage architecture is configured through RAGAnythingConfig, allowing users to swap backends by changing configuration parameters. Integration with LightRAG's storage layer enables seamless persistence of indexed documents, embeddings, and knowledge graph data.

Provides a ProcessorMixin-based framework for developing custom modal processors that handle domain-specific content types beyond images, tables, and equations. Custom processors inherit from a base processor class and implement extraction and embedding logic, integrating seamlessly into the five-stage pipeline. The framework enables users to add processors for specialized formats (e.g., audio transcripts, video frames, chemical structures) without modifying core pipeline code.

Automatically constructs a knowledge graph by extracting entities and relationships from all modalities (text, images, tables, equations) using LightRAG's entity extraction engine. The system maps entities across modalities (e.g., linking an entity mentioned in text to an image containing that entity) and builds a unified graph representation. Entity extraction is configurable per modality, allowing users to tune extraction parameters for different content types.

Centralizes all system configuration through RAGAnythingConfig dataclass, supporting environment variable overrides for deployment flexibility. Configuration covers model providers (LLM, embedding, vision models), storage backends, parser selection, and processing parameters. The config system enables users to deploy the same codebase across environments (dev, staging, production) by changing configuration without code modifications.

Supports integration with local language models (via Ollama, vLLM, or compatible APIs) for offline deployment scenarios where cloud API access is unavailable. The system abstracts LLM provider selection through configuration, allowing users to swap between OpenAI, Anthropic, and local models without code changes. Offline deployment is fully supported with local embeddings, local LLMs, and local storage backends.