{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-redisearch--redisearch","slug":"redisearch--redisearch","name":"RediSearch","type":"mcp","url":"https://redis.io/docs/latest/develop/ai/search-and-query/","page_url":"https://unfragile.ai/redisearch--redisearch","categories":["mcp-servers","rag-knowledge"],"tags":["fulltext","geospatial","gis","inverted-index","redis","redis-module","search","search-engine","vector-database"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-redisearch--redisearch__cap_0","uri":"capability://search.retrieval.full.text.search.with.boolean.operators.and.phrase.matching","name":"full-text search with boolean operators and phrase matching","description":"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.","intents":["Search documents by keywords with boolean logic (e.g., 'redis AND (search OR index)')","Find exact phrases within indexed text fields","Perform fuzzy/typo-tolerant searches on misspelled terms","Build full-text search into a Redis-backed application without external search engines"],"best_for":["Teams building search-heavy applications on Redis infrastructure","Developers needing full-text search without Elasticsearch/Solr operational overhead","Applications with sub-second latency requirements on indexed text"],"limitations":["Inverted index is built incrementally; large bulk indexing may cause temporary memory spikes","Phrase proximity queries have configurable slop but exact phrase matching is more efficient than proximity ranges","Fuzzy search performance degrades with very large edit distance thresholds (>2 recommended)"],"requires":["Redis 6.0+ with module loading enabled","RediSearch module compiled and loaded via LoadModule directive","Index created with FT.CREATE command specifying TEXT field type"],"input_types":["text (from Redis hash fields or JSON documents)","query strings with boolean operators and quoted phrases"],"output_types":["document IDs with relevance scores","ranked result sets with field snippets"],"categories":["search-retrieval","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_1","uri":"capability://search.retrieval.vector.similarity.search.with.multiple.indexing.algorithms","name":"vector similarity search with multiple indexing algorithms","description":"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.","intents":["Find semantically similar documents using pre-computed embeddings (e.g., from LLMs)","Implement recommendation systems based on vector similarity","Build hybrid search combining full-text and vector similarity in a single query","Scale vector search to millions of embeddings with sub-millisecond latency"],"best_for":["RAG (Retrieval-Augmented Generation) pipelines needing fast semantic search","Recommendation engines with embedding-based similarity","Teams building AI/ML applications on Redis without separate vector DB","Applications requiring sub-100ms p99 latency on vector queries"],"limitations":["FLAT algorithm has O(n) query complexity; suitable only for <100k vectors","HNSW memory overhead is ~2-3x the raw vector size due to graph structure; tunable via M and EF parameters","Vector dimension must be fixed at index creation time; no dynamic resizing","Distance metric (cosine/L2/inner product) is set per field and cannot be changed without reindexing"],"requires":["Redis 6.0+ with RediSearch module","Vector field defined in index schema with FT.CREATE using VECTOR type","Pre-computed embeddings (768-1536 dimensions typical for LLM embeddings)","Algorithm choice specified at index creation (FLAT, HNSW, or SVS)"],"input_types":["binary vector data (float32 arrays)","vector dimension (e.g., 768 for OpenAI embeddings)","distance metric specification (COSINE, L2, IP)"],"output_types":["ranked document IDs with similarity scores","top-k nearest neighbors with distance values"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_10","uri":"capability://automation.workflow.concurrent.query.execution.with.thread.safe.locking","name":"concurrent query execution with thread-safe locking","description":"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.","intents":["Execute multiple search queries concurrently without blocking","Safely update indexes while queries are executing","Prevent data corruption from concurrent modifications","Maintain query performance under high concurrency"],"best_for":["High-concurrency search applications with many simultaneous queries","Systems with frequent index updates and concurrent searches","Applications requiring consistent results under concurrent modifications"],"limitations":["Write locks (index modifications) block concurrent queries; bulk indexing may cause query latency spikes","Garbage collection runs asynchronously; deleted documents may remain in index temporarily","Lock contention increases latency under very high concurrency (>1000 concurrent queries)"],"requires":["Redis 6.0+ with RediSearch module","Redis compiled with threading support (default in most builds)"],"input_types":["concurrent FT.SEARCH, FT.ADD, FT.DEL commands"],"output_types":["consistent query results despite concurrent modifications"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_11","uri":"capability://automation.workflow.persistence.and.replication.of.indexes","name":"persistence and replication of indexes","description":"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.","intents":["Persist search indexes across server restarts","Replicate indexes to Redis replica nodes for high availability","Ensure index consistency between primary and replica nodes","Enable disaster recovery with index snapshots"],"best_for":["Production systems requiring index durability","High-availability deployments with replica nodes","Applications where index loss is unacceptable"],"limitations":["RDB snapshots include full index structures; large indexes increase snapshot size and time","Index replication adds network overhead; very large indexes may increase replication lag","Incremental snapshots are not supported; full snapshots are required","Index recovery from RDB is synchronous; large indexes may delay server startup"],"requires":["Redis 6.0+ with RediSearch module","RDB persistence enabled (save directive in redis.conf)","Replica nodes with RediSearch module for replication"],"input_types":["index structures created by FT.CREATE and FT.ADD"],"output_types":["persisted index data in RDB snapshots","replicated indexes on replica nodes"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_12","uri":"capability://planning.reasoning.scoring.and.ranking.with.bm25.and.custom.weights","name":"scoring and ranking with bm25 and custom weights","description":"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.","intents":["Rank search results by relevance using BM25 algorithm","Boost relevance of specific fields (e.g., title vs. body)","Sort results by relevance score","Customize ranking behavior for domain-specific relevance"],"best_for":["Full-text search applications requiring relevance ranking","Search UIs where result ordering impacts user experience","Applications with domain-specific relevance requirements"],"limitations":["BM25 is fixed algorithm; custom scoring functions are not supported","Field weights are static (set at index creation); dynamic weight adjustment requires reindexing","Scoring is text-only; numeric and vector results are not scored with BM25","BM25 parameters (k1, b) are global; per-field tuning is not supported"],"requires":["Redis 6.0+ with RediSearch module","Full-text search query (FT.SEARCH with TEXT fields)","Field weights specified in FT.CREATE (optional)"],"input_types":["full-text search query","field weight specifications"],"output_types":["ranked results with BM25 scores","results sorted by relevance"],"categories":["planning-reasoning","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_13","uri":"capability://text.generation.language.tokenization.and.stemming.for.text.field.processing","name":"tokenization and stemming for text field processing","description":"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.","intents":["Normalize text for consistent full-text search (e.g., 'running' matches 'run')","Remove common words (stopwords) to reduce index size","Support case-insensitive search","Improve search recall by matching word variants"],"best_for":["Full-text search applications requiring linguistic normalization","Multi-language search systems (with language-specific stemmers)","Applications where search recall is important"],"limitations":["Stemming is language-specific; only English stemming is built-in","Stopword lists are fixed; custom stopwords require recompilation","Tokenization is whitespace-based; no support for custom tokenization rules","Stemming may over-generalize (e.g., 'universe' and 'university' both stem to 'univers')"],"requires":["Redis 6.0+ with RediSearch module","TEXT field type specified in FT.CREATE","Tokenization rules applied at index creation"],"input_types":["text content from Redis documents"],"output_types":["tokenized and stemmed terms in inverted index"],"categories":["text-generation-language","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_2","uri":"capability://data.processing.analysis.numeric.range.queries.and.aggregations","name":"numeric range queries and aggregations","description":"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.","intents":["Filter documents by numeric ranges (e.g., price between $10-$100, timestamp after 2024-01-01)","Aggregate numeric fields across result sets (e.g., sum of sales, average rating)","Build faceted search with numeric facets (e.g., price ranges)","Perform time-series queries on indexed numeric timestamps"],"best_for":["E-commerce applications with price range filtering","Analytics dashboards aggregating numeric metrics","Time-series data indexed in Redis with range-based queries","Applications combining text search with numeric filtering"],"limitations":["Numeric range tree is optimized for range queries; point lookups are not faster than hash table","Aggregations require loading all matching documents into memory; very large result sets (>1M docs) may cause memory pressure","Numeric precision is limited by Redis' float representation; integer fields are stored as 64-bit signed integers"],"requires":["Redis 6.0+ with RediSearch module","Index created with NUMERIC field type via FT.CREATE","Numeric values stored in Redis hashes or JSON documents as valid numbers"],"input_types":["numeric values (integers or floats)","range bounds (min/max) in query syntax"],"output_types":["filtered document IDs matching range criteria","aggregated numeric results (SUM, AVG, MIN, MAX, COUNT)"],"categories":["data-processing-analysis","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_3","uri":"capability://search.retrieval.geospatial.and.geometric.queries","name":"geospatial and geometric queries","description":"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.","intents":["Find locations within a radius (e.g., nearby restaurants, ATMs)","Query by bounding box (e.g., all stores in a geographic region)","Perform spatial joins combining location-based and text-based filters","Build location-aware recommendation systems"],"best_for":["Location-based services and mapping applications","Ride-sharing and delivery platforms with proximity search","Real estate and property search with geographic filtering","Applications combining geospatial and full-text search"],"limitations":["Geohashing precision is limited by the hash resolution; very small radius queries (<100m) may return false positives requiring post-filtering","GEOMETRY queries are less optimized than GEO; complex polygon queries may have higher latency","Radius search returns results in arbitrary order; sorting by distance requires post-processing"],"requires":["Redis 6.0+ with RediSearch module","Index created with GEO or GEOMETRY field type","Coordinates stored as longitude,latitude pairs in Redis hashes or JSON"],"input_types":["latitude/longitude coordinates (decimal degrees)","radius in meters/kilometers","polygon/linestring geometries (WKT format)"],"output_types":["document IDs of locations within radius/bounds","results with distance values (for radius queries)"],"categories":["search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_4","uri":"capability://data.processing.analysis.aggregation.pipeline.with.grouping.reduction.and.expression.evaluation","name":"aggregation pipeline with grouping, reduction, and expression evaluation","description":"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.","intents":["Group search results by field and compute aggregate metrics (e.g., average price per category)","Build analytics queries combining filtering, grouping, and aggregation","Create dashboards with multi-level aggregations (e.g., sales by region and product)","Compute derived fields during aggregation (e.g., profit = price - cost)"],"best_for":["Analytics and reporting applications on Redis data","E-commerce platforms computing category-level metrics","Real-time dashboards aggregating event data","Teams avoiding separate OLAP databases for simple aggregations"],"limitations":["Aggregation pipeline materializes all intermediate results in memory; very large result sets (>10M rows) may cause OOM","Expression evaluation is limited to mathematical operations and field references; no user-defined functions","Grouping is single-level; hierarchical grouping requires multiple queries","Sorting aggregated results requires loading all groups into memory before sort"],"requires":["Redis 6.0+ with RediSearch module","FT.AGGREGATE command with pipeline stages specified","Source index created with FT.CREATE"],"input_types":["query filter (optional, to pre-filter documents)","grouping field specification","reduction operations (SUM, AVG, MIN, MAX, COUNT)","expression strings for computed fields"],"output_types":["grouped result sets with aggregate metrics","structured data with computed fields"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_5","uri":"capability://data.processing.analysis.index.schema.definition.and.field.type.management","name":"index schema definition and field type management","description":"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.","intents":["Define which fields in Redis documents are searchable and how they should be indexed","Specify field types to optimize index structure (e.g., NUMERIC for range queries, TAG for exact matching)","Configure tokenization and stemming for text fields","Create multiple independent indexes on the same Redis data"],"best_for":["Developers building search-enabled applications on Redis","Teams needing flexible schema evolution without reindexing","Applications with multiple search use cases (full-text, vector, numeric) on the same data"],"limitations":["Schema is immutable after index creation; field types cannot be changed without dropping and recreating the index","Field names must match exactly in source documents; no schema inference or automatic field discovery","Index creation is synchronous and blocks Redis during large document indexing; no async index building","Tokenization rules (stemming, stopwords) are global per field; no per-document customization"],"requires":["Redis 6.0+ with RediSearch module","FT.CREATE command with schema definition","Source data in Redis hashes or JSON documents"],"input_types":["field name and type specification (TEXT, NUMERIC, TAG, VECTOR, GEO, GEOMETRY)","field options (SORTABLE, NOINDEX, WEIGHT for TEXT, ALGORITHM for VECTOR)"],"output_types":["index specification stored in Redis","index structures created for each field type"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_6","uri":"capability://automation.workflow.incremental.document.indexing.via.keyspace.notifications","name":"incremental document indexing via keyspace notifications","description":"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.","intents":["Keep search indexes automatically synchronized with document changes","Avoid manual reindexing after document updates","Build real-time search applications where indexes reflect current data","Reduce operational overhead of index maintenance"],"best_for":["Real-time search applications with frequent document updates","Teams avoiding batch indexing jobs and associated complexity","Applications where index staleness is unacceptable"],"limitations":["Keyspace notifications must be enabled in Redis config (notify-keyspace-events); adds CPU overhead","Incremental updates are slower than batch indexing for bulk operations; large bulk inserts should use FT.ADD in batches","Notification-based updates are asynchronous; there is a small window where index may lag behind source data","Deleting documents requires explicit FT.DEL command; automatic deletion via Redis DEL does not remove from index (requires garbage collection)"],"requires":["Redis 6.0+ with RediSearch module","Keyspace notifications enabled in Redis config: notify-keyspace-events = KEA (or at least Kh for hash events)","Index created with FT.CREATE"],"input_types":["document modifications in Redis (HSET, HGETALL, JSON.SET, etc.)"],"output_types":["automatically updated index structures"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_7","uri":"capability://planning.reasoning.query.parsing.and.execution.with.query.node.tree","name":"query parsing and execution with query node tree","description":"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.","intents":["Parse complex search queries with boolean logic and field-specific filters","Execute queries efficiently by leveraging appropriate index structures for each query component","Support advanced query syntax (phrases, ranges, field-specific queries)","Rank results by relevance using BM25 or other scoring algorithms"],"best_for":["Applications with complex search requirements (boolean operators, field-specific queries)","Teams building search UIs with advanced query syntax","Systems requiring efficient query execution on large indexes"],"limitations":["Query parsing is strict; invalid syntax returns errors rather than attempting recovery","Query optimization is limited; complex queries with many OR clauses may be slower than optimized queries","Scoring is BM25-based for text; custom scoring functions are not supported","Query timeout is configurable but queries cannot be interrupted mid-execution"],"requires":["Redis 6.0+ with RediSearch module","Index created with FT.CREATE","Query string in FT.SEARCH command"],"input_types":["query strings with boolean operators (AND, OR, NOT), quoted phrases, range syntax (e.g., @price:[10 100])"],"output_types":["ranked document IDs with relevance scores","query execution statistics (processing time, documents scanned)"],"categories":["planning-reasoning","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_8","uri":"capability://search.retrieval.distributed.search.across.redis.cluster.nodes","name":"distributed search across redis cluster nodes","description":"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.","intents":["Search across multiple Redis cluster nodes transparently","Scale search to datasets larger than a single node's memory","Perform aggregations across distributed data","Build high-availability search systems with automatic failover"],"best_for":["Large-scale applications with data sharded across Redis cluster","Teams using Redis Enterprise with cluster deployments","Applications requiring search across terabytes of data"],"limitations":["Distributed queries have higher latency than single-node queries due to network round-trips","Aggregations require collecting partial results from all nodes; very large aggregations may have memory overhead","Query distribution is automatic based on key hashing; custom sharding strategies are not supported","Distributed search is only available in Redis Enterprise; open-source Redis does not support clustering"],"requires":["Redis Enterprise with cluster mode enabled","RediSearch module installed on all cluster nodes","Data distributed across cluster via Redis' key hashing"],"input_types":["FT.SEARCH or FT.AGGREGATE commands (same syntax as single-node)"],"output_types":["merged results from all cluster nodes","aggregated results combining partial aggregations"],"categories":["search-retrieval","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-redisearch--redisearch__cap_9","uri":"capability://data.processing.analysis.document.table.and.field.lookup.with.rlookup.system","name":"document table and field lookup with rlookup system","description":"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.","intents":["Retrieve field values for documents matching a query","Support result projection (return only specified fields)","Enable efficient aggregation by looking up field values on-demand","Reduce memory overhead by lazy-loading fields"],"best_for":["Applications returning partial document data (not full documents)","Aggregations requiring field lookups on large result sets","Systems with memory constraints where lazy-loading is beneficial"],"limitations":["RLookup adds latency for field retrieval; caching helps but adds memory overhead","Field lookup requires accessing source documents in Redis; if source is deleted, lookup fails","Lazy loading is beneficial for large documents but adds per-field latency for small documents"],"requires":["Redis 6.0+ with RediSearch module","Source documents in Redis hashes or JSON","Index created with FT.CREATE"],"input_types":["document IDs from query results","field names to retrieve"],"output_types":["field values for specified documents","structured result sets with projected fields"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":53,"verified":false,"data_access_risk":"high","permissions":["Redis 6.0+ with module loading enabled","RediSearch module compiled and loaded via LoadModule directive","Index created with FT.CREATE command specifying TEXT field type","Redis 6.0+ with RediSearch module","Vector field defined in index schema with FT.CREATE using VECTOR type","Pre-computed embeddings (768-1536 dimensions typical for LLM embeddings)","Algorithm choice specified at index creation (FLAT, HNSW, or SVS)","Redis compiled with threading support (default in most builds)","RDB persistence enabled (save directive in redis.conf)","Replica nodes with RediSearch module for replication"],"failure_modes":["Inverted index is built incrementally; large bulk indexing may cause temporary memory spikes","Phrase proximity queries have configurable slop but exact phrase matching is more efficient than proximity ranges","Fuzzy search performance degrades with very large edit distance thresholds (>2 recommended)","FLAT algorithm has O(n) query complexity; suitable only for <100k vectors","HNSW memory overhead is ~2-3x the raw vector size due to graph structure; tunable via M and EF parameters","Vector dimension must be fixed at index creation time; no dynamic resizing","Distance metric (cosine/L2/inner product) is set per field and cannot be changed without reindexing","Write locks (index modifications) block concurrent queries; bulk indexing may cause query latency spikes","Garbage collection runs asynchronously; deleted documents may remain in index temporarily","Lock contention increases latency under very high concurrency (>1000 concurrent queries)","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.608518136508829,"quality":0.5,"ecosystem":0.7000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.063Z","last_scraped_at":"2026-05-03T13:58:32.037Z","last_commit":"2026-05-03T13:56:05Z"},"community":{"stars":6122,"forks":582,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=redisearch--redisearch","compare_url":"https://unfragile.ai/compare?artifact=redisearch--redisearch"}},"signature":"3eN+dl52L3nzbebkKPKB6WziOlSt2OcOcwgBdJnl9IlHXSKd+CohLQIPJhlsdi6hWBxSMsDVN9AGN//GP+BvDw==","signedAt":"2026-06-19T23:16:36.278Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/redisearch--redisearch","artifact":"https://unfragile.ai/redisearch--redisearch","verify":"https://unfragile.ai/api/v1/verify?slug=redisearch--redisearch","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}