RediSearch

Implements full-text search via inverted index structures that map tokenized terms to document IDs, supporting boolean operators (AND, OR, NOT), phrase matching with proximity constraints, and fuzzy matching via edit distance. The indexing pipeline tokenizes text fields during document ingestion and maintains a trie-based term dictionary for efficient prefix and wildcard queries. Query parsing converts user input into a query node tree (src/query_node.h) that is executed against the inverted index to return ranked results.

Implements vector similarity search by supporting multiple approximate nearest neighbor (ANN) algorithms: FLAT (brute-force), HNSW (Hierarchical Navigable Small World), and SVS (Streaming Vector Search). Vectors are indexed as VECTOR field types during document ingestion and stored in specialized index structures. Query execution performs similarity search using cosine, L2, or inner product distance metrics, returning top-k nearest neighbors ranked by distance. The module integrates with Redis' native data types, storing vectors as binary blobs in hashes or JSON documents.

Implements thread-safe concurrent query execution using reader-writer locks and atomic operations. Multiple queries can execute concurrently on the same index (read-only operations), while index modifications (document addition/deletion) acquire write locks to prevent concurrent modification. The module uses Redis' threading model and integrates with Redis' event loop for non-blocking execution. Garbage collection (src/spec.c) runs asynchronously to clean up deleted documents without blocking queries.

Integrates with Redis' persistence and replication mechanisms to ensure indexes survive server restarts and are replicated to replica nodes. Index structures are serialized during RDB snapshots and deserialized on startup. For replication, index modifications are propagated to replicas via Redis' replication stream, ensuring replicas maintain consistent indexes. The module registers custom Redis types (IndexSpecType, InvertedIndexType) to enable proper serialization/deserialization.

Implements relevance scoring using BM25 algorithm (Okapi BM25) for full-text search results, with configurable parameters (k1, b) for tuning. Field-level weights can be specified at index creation time to boost relevance of certain fields (e.g., title weighted higher than description). Results are ranked by BM25 score, with ties broken by document ID. The scoring system integrates with query execution to compute scores during result collection.

Implements text processing pipeline for TEXT fields including tokenization (splitting text into terms), lowercasing, stopword removal, and stemming (reducing words to root form). Tokenization rules are specified at field creation time and applied during document indexing. The module supports multiple stemming algorithms (Porter stemmer) and configurable stopword lists. Tokenized terms are stored in the inverted index for efficient full-text search.

Implements numeric range queries using a numeric range tree data structure (src/spec.h) that indexes NUMERIC field types for efficient range filtering. Queries specify min/max bounds and return documents within the range. The module also supports numeric aggregations (SUM, AVG, MIN, MAX, COUNT) via the aggregation framework (src/aggregate/aggregate.h), which processes result sets through a pipeline of reduction operators. Numeric fields are indexed separately from text, enabling fast range scans without full-text index overhead.

Implements geospatial search via GEO field type for latitude/longitude-based queries and GEOMETRY field type for complex spatial shapes. GEO fields use geohashing to index points and support radius searches (e.g., 'find all restaurants within 5km'). GEOMETRY fields support polygon/linestring queries for more complex spatial relationships. Both field types are indexed separately and integrated into the query execution engine, allowing spatial filters to be combined with text and numeric filters in a single query.

Implements a multi-stage aggregation pipeline (src/aggregate/aggregate.h, src/aggregate/aggregate_exec.c) that processes query results through configurable stages: filtering, grouping, reduction (SUM/AVG/MIN/MAX/COUNT), sorting, and limiting. Each stage is a result processor that transforms data; stages are chained together in execution order. The pipeline supports expression evaluation (src/result_processor.h) for computed fields, allowing mathematical operations and field transformations during aggregation. Results are materialized in memory and returned as structured data.

Provides a schema definition system (IndexSpec in src/spec.h) that allows developers to declare searchable fields with specific types (TEXT, NUMERIC, TAG, VECTOR, GEO, GEOMETRY) and indexing options. The FT.CREATE command parses schema definitions and creates index structures tailored to each field type. Field specifications include tokenization rules for TEXT (e.g., stemming, stopwords), distance metrics for VECTOR, and precision for NUMERIC. The module maintains a global specDict_g dictionary mapping index names to IndexSpec structures, enabling multi-index support.

Implements real-time index updates by subscribing to Redis keyspace notifications (src/redis_index.c) for document changes (SET, DEL, HSET, etc.). When a document is modified, the module automatically detects the change and updates all relevant indexes without explicit reindexing commands. This is achieved through Redis' keyspace event subscription mechanism, which notifies the module of key modifications. The indexing pipeline (src/redis_index.c) processes these events and updates inverted indexes, numeric trees, vector indexes, and other index structures incrementally.

Implements a two-stage query processing system: parsing (src/query.c) converts user query strings into a query node tree (src/query_node.h) representing the logical structure (AND, OR, NOT, phrase, range, etc.), and execution evaluates the tree against index structures to produce result sets. The query parser handles boolean operators, quoted phrases, range syntax, and field-specific queries. Query execution traverses the tree, performing set operations (intersection, union, complement) on document ID sets from different index types (inverted, numeric, vector, geo). Results are scored and ranked based on relevance metrics.

Provides distributed query execution for Redis Enterprise clusters (src/coord/dist_aggregate.c) by coordinating queries across multiple cluster nodes. When a query is executed on a cluster, the module distributes the query to relevant nodes (based on key distribution), collects partial results, and merges them on the coordinator node. Aggregations are also distributed: each node performs local aggregation, and the coordinator performs final aggregation on partial results. This enables searching across sharded data without application-level coordination.

Maintains a document table (src/spec.h) that stores document metadata and field values for all indexed documents. The RLookup system (src/rlookup.h, src/rlookup.c) provides efficient field lookup by document ID, enabling retrieval of field values during query execution and aggregation. RLookup supports lazy loading (fields are fetched from source documents on-demand) and caching (frequently accessed fields are cached in memory). This system enables efficient result construction without loading entire documents into memory.