# Redis Search errors

```json metadata
{
  "schema_version": 2,
  "title": "Redis Search errors",
  "description": "Every error message that Redis Search returns in Redis 8.10",
  "categories": ["docs","develop","stack","oss","rs","rc","oss","kubernetes","clients"],
  "tableOfContents": {"sections":[{"children":[{"id":"search_syntax","title":"SEARCH_SYNTAX"},{"id":"search_query_string_bad","title":"SEARCH_QUERY_STRING_BAD"},{"id":"search_keyword","title":"SEARCH_KEYWORD"},{"id":"search_field_missing_req","title":"SEARCH_FIELD_MISSING_REQ"},{"id":"search_order_option_bad","title":"SEARCH_ORDER_OPTION_BAD"},{"id":"search_param_not_found","title":"SEARCH_PARAM_NOT_FOUND"},{"id":"search_no_results","title":"SEARCH_NO_RESULTS"},{"id":"search_build_plan","title":"SEARCH_BUILD_PLAN"}],"id":"query-syntax","title":"Query syntax"},{"children":[{"id":"search_parse_args","title":"SEARCH_PARSE_ARGS"},{"id":"search_arg_unrecognized","title":"SEARCH_ARG_UNRECOGNIZED"},{"id":"search_add_args","title":"SEARCH_ADD_ARGS"},{"id":"search_option_invalid","title":"SEARCH_OPTION_INVALID"},{"id":"search_option_bad","title":"SEARCH_OPTION_BAD"},{"id":"search_attr_bad","title":"SEARCH_ATTR_BAD"},{"id":"search_value_bad","title":"SEARCH_VALUE_BAD"},{"id":"search_numeric_value_invalid","title":"SEARCH_NUMERIC_VALUE_INVALID"},{"id":"search_param_dup","title":"SEARCH_PARAM_DUP"},{"id":"search_field_dup","title":"SEARCH_FIELD_DUP"},{"id":"search_query_bad","title":"SEARCH_QUERY_BAD"}],"id":"command-arguments","title":"Command arguments"},{"children":[{"id":"search_index_not_found","title":"SEARCH_INDEX_NOT_FOUND"},{"id":"search_index_exists","title":"SEARCH_INDEX_EXISTS"},{"id":"search_alias_conflict","title":"SEARCH_ALIAS_CONFLICT"},{"id":"search_index_dropped_bg","title":"SEARCH_INDEX_DROPPED_BG"},{"id":"search_path_bad","title":"SEARCH_PATH_BAD"}],"id":"indexes","title":"Indexes"},{"children":[{"id":"search_doc_not_found","title":"SEARCH_DOC_NOT_FOUND"},{"id":"search_document_exists","title":"SEARCH_DOCUMENT_EXISTS"},{"id":"search_document_not_added","title":"SEARCH_DOCUMENT_NOT_ADDED"},{"id":"noadd","title":"NOADD"},{"id":"search_redis_key_type_bad","title":"SEARCH_REDIS_KEY_TYPE_BAD"},{"id":"search_type_unsup","title":"SEARCH_TYPE_UNSUP"},{"id":"search_json_type_invalid","title":"SEARCH_JSON_TYPE_INVALID"},{"id":"search_geo_coordinates_invalid","title":"SEARCH_GEO_COORDINATES_INVALID"},{"id":"search_geo_format_bad","title":"SEARCH_GEO_FORMAT_BAD"},{"id":"search_vector_blob_size_mismatch","title":"SEARCH_VECTOR_BLOB_SIZE_MISMATCH"},{"id":"search_vector_len_bad","title":"SEARCH_VECTOR_LEN_BAD"}],"id":"documents","title":"Documents"},{"children":[{"id":"search_prop_not_found","title":"SEARCH_PROP_NOT_FOUND"},{"id":"search_value_not_found","title":"SEARCH_VALUE_NOT_FOUND"},{"id":"search_expr","title":"SEARCH_EXPR"},{"id":"search_reducer_not_found","title":"SEARCH_REDUCER_NOT_FOUND"},{"id":"search_reducer_error","title":"SEARCH_REDUCER_ERROR"},{"id":"search_reducer_init_failed","title":"SEARCH_REDUCER_INIT_FAILED"},{"id":"search_agg_plan","title":"SEARCH_AGG_PLAN"},{"id":"search_construct_pipeline","title":"SEARCH_CONSTRUCT_PIPELINE"},{"id":"search_cursor_alloc_failed","title":"SEARCH_CURSOR_ALLOC_FAILED"}],"id":"aggregations","title":"Aggregations"},{"children":[{"id":"search_hybrid_policy_bad","title":"SEARCH_HYBRID_POLICY_BAD"},{"id":"search_hybrid_attr_non_hybrid","title":"SEARCH_HYBRID_ATTR_NON_HYBRID"},{"id":"search_adhoc_batch_size_irrelevant","title":"SEARCH_ADHOC_BATCH_SIZE_IRRELEVANT"},{"id":"search_adhoc_ef_runtime_irrelevant","title":"SEARCH_ADHOC_EF_RUNTIME_IRRELEVANT"},{"id":"search_range_attr_non_range","title":"SEARCH_RANGE_ATTR_NON_RANGE"},{"id":"search_vector_not_allowed","title":"SEARCH_VECTOR_NOT_ALLOWED"},{"id":"search_weight_not_allowed","title":"SEARCH_WEIGHT_NOT_ALLOWED"},{"id":"search_safe_depleter_failure","title":"SEARCH_SAFE_DEPLETER_FAILURE"}],"id":"vector-and-hybrid-queries","title":"Vector and hybrid queries"},{"children":[{"id":"search_limit_over","title":"SEARCH_LIMIT_OVER"},{"id":"search_timeout","title":"SEARCH_TIMEOUT"},{"id":"search_oom","title":"SEARCH_OOM"},{"id":"search_index_bg_oom_fail","title":"SEARCH_INDEX_BG_OOM_FAIL"}],"id":"resources-and-limits","title":"Resources and limits"},{"children":[{"id":"errcluster","title":"ERRCLUSTER"},{"id":"search_cluster_no_responses","title":"SEARCH_CLUSTER_NO_RESPONSES"},{"id":"search_slots_unavail","title":"SEARCH_SLOTS_UNAVAIL"},{"id":"search_index_mismatch","title":"SEARCH_INDEX_MISMATCH"},{"id":"search_dist_failed","title":"SEARCH_DIST_FAILED"}],"id":"clusters","title":"Clusters"},{"children":[{"id":"search_flex_limit_number_of_indexes","title":"SEARCH_FLEX_LIMIT_NUMBER_OF_INDEXES"},{"id":"search_flex_unsupported_field","title":"SEARCH_FLEX_UNSUPPORTED_FIELD"},{"id":"search_flex_unsupported_ft_create_argument","title":"SEARCH_FLEX_UNSUPPORTED_FT_CREATE_ARGUMENT"},{"id":"search_flex_unsupported_query","title":"SEARCH_FLEX_UNSUPPORTED_QUERY"},{"id":"search_flex_unsupported_argument","title":"SEARCH_FLEX_UNSUPPORTED_ARGUMENT"},{"id":"search_flex_search_load_unsupported","title":"SEARCH_FLEX_SEARCH_LOAD_UNSUPPORTED"},{"id":"search_flex_search_nocontent_or_return_0_required","title":"SEARCH_FLEX_SEARCH_NOCONTENT_OR_RETURN_0_REQUIRED"},{"id":"search_disk_creation","title":"SEARCH_DISK_CREATION"},{"id":"search_disk_iterator_creation","title":"SEARCH_DISK_ITERATOR_CREATION"}],"id":"redis-flex-and-disk-indexes","title":"Redis Flex and disk indexes"},{"children":[{"id":"search_generic","title":"SEARCH_GENERIC"},{"id":"err","title":"ERR"},{"id":"noperm","title":"NOPERM"},{"id":"wrongtype","title":"WRONGTYPE"}],"id":"other-codes","title":"Other codes"},{"id":"messages-without-a-code","title":"Messages without a code"}]}

,
  "codeExamples": []
}
```


These are the error messages of [Redis Search](https://redis.io/docs/latest/develop/ai/search-and-query) commands, such as `FT.CREATE`, `FT.SEARCH`, and `FT.AGGREGATE`. Most of them start with an error code that begins with `SEARCH_`, such as `SEARCH_INDEX_NOT_FOUND` or `SEARCH_SYNTAX`. A description follows the code. Some messages have no code, and [Messages without a code](#messages-without-a-code) lists them.

A few messages never come back as the reply to a command. Instead, [`FT.INFO`](https://redis.io/docs/latest/commands/ft.info) shows them as the last error that happened while indexing a document.

## Query syntax

### SEARCH_SYNTAX

Redis Search couldn't parse the query string of `FT.SEARCH`, `FT.AGGREGATE`, or a similar command, or the arguments of `FT.HYBRID`. Many messages give the position of the problem, as an offset, and the text near it. A message such as `Expected a TAG field` means that the query uses the syntax of one field type on a field of another type. To fix it, check the query at that position for a typo, a missing parenthesis or bracket, or a special character that needs escaping. For the syntax, see [Query syntax](https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/query_syntax).

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_SYNTAX 'ismissing' requires defining the field with 'INDEXMISSING' at offset <position> near <token>` | Your query calls `ismissing()` on a field that wasn't defined with `INDEXMISSING`, so the index doesn't track which documents lack it. Re-create the index with `INDEXMISSING` on that field. Or use `FT.ALTER` to add the same field again under a new name with `INDEXMISSING`, and query that name. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Bad arguments in <clause>: <reason>` | `FT.HYBRID` couldn't take the counted arguments of `COMBINE RRF` or `COMBINE LINEAR`. In Redis 8.10 a count that's too large returns `Not enough arguments in ...` instead, so you shouldn't see this message. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Bad arguments in FILTER: <reason>` | `FT.HYBRID` couldn't take the counted arguments of `FILTER` in the `VSIM` clause. In Redis 8.10 a count that's too large returns `Not enough arguments in FILTER ...` instead, so you shouldn't see this message. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Expected a GEO field at offset <position> near <token>` | Your query uses a geo radius filter, `@field:[lon lat radius unit]`, on a field that isn't a `GEO` field. The text after `near` names the field. Use a `GEO` field, or the query syntax of the field's type, which `FT.INFO` shows. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Expected a GEOSHAPE field at offset <position> near <token>` | Your query uses a shape filter, such as `@field:[WITHIN $shape]`, on a field that isn't a `GEOSHAPE` field. The text after `near` names the field. Run shape queries on a `GEOSHAPE` field, or use the query syntax of the field's type. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Expected a NUMERIC field at offset <position> near <token>` | Your query uses a numeric range, such as `@field:[1 10]`, or a comparison, such as `@field == 5`, on a field that isn't `NUMERIC`. The text after `near` names the field. Use a `NUMERIC` field, or the query syntax of the field's type, which `FT.INFO` shows. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Expected a TAG field at offset <position> near <token>` | Your query uses tag syntax, `@field:{value}`, on a field that isn't a `TAG` field. The text after `near` names the field. Use the syntax of the field's type, such as `@field:term` for `TEXT` or `@field:[min max]` for `NUMERIC`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Expected a TEXT field at offset <position> near <token>` | Your query searches for text, as in `@field:term` or `@field1\|field2:term`, in a field that isn't a `TEXT` field. The text after `near` names the field. Search a `TEXT` field, or use the query syntax of that field's type. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `` SEARCH_SYNTAX Expected a VECTOR field `<field>` `` | The `VSIM` clause of `FT.HYBRID` names a field that's in the index but isn't a `VECTOR` field. Use the name of a `VECTOR` field of the index in `VSIM`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_SYNTAX Expected a VECTOR field at offset <position> near <token>` | Your query runs a vector search, `KNN` or `VECTOR_RANGE`, on a field that isn't a `VECTOR` field. The text after `near` names the field. Use the name of a `VECTOR` field of the index, which `FT.INFO` lists. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Expected arguments <number>, but <number> <verb> provided` | The count after `KNN` or `RANGE` in the `VSIM` clause of `FT.HYBRID` is larger than the number of arguments that follow. The message shows the count and how many arguments there are. Correct the count, or add the missing pairs. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Invalid argument count: <number> (must be a positive even number for key/value pairs)` | The count after `KNN` or `RANGE` in the `VSIM` clause of `FT.HYBRID` is 0 or odd. Its arguments come in name and value pairs, so use an even count of 2 or more, such as `KNN 2 K 10`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Invalid EF_RUNTIME value` | `EF_RUNTIME` in the `KNN` arguments of `FT.HYBRID` must be a whole number of 1 or more. Correct the value, such as `EF_RUNTIME 100`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Invalid EPSILON value` | `EPSILON` in the `RANGE` arguments of `FT.HYBRID` must be a number greater than 0. Correct the value, such as `EPSILON 0.01`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Invalid GeoFilter lat/lon` | A geo filter has a longitude outside -180 to 180 or a latitude outside -90 to 90. This applies to `GEOFILTER` and to a query such as `@location:[lon lat radius unit]`, so check the values and that the longitude comes first. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Invalid GeoFilter radius` | The radius of a geo filter, in `GEOFILTER` or in a query such as `@location:[lon lat radius unit]`, is 0 or negative. Give a radius greater than 0. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Invalid GeoFilter unit` | The unit of a geo query such as `@location:[-122.41 37.77 5 km]`, or of the parameter used as its unit, isn't one that Redis Search knows. Use `m`, `km`, `mi`, or `ft`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Invalid K value` | `K` in the `KNN` arguments of `FT.HYBRID`, the number of neighbors to return, must be a whole number of 1 or more. Correct the value, such as `K 10`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Invalid numeric range (min > max): @<field>:[<min> <max>]` | A numeric range in the query has a minimum greater than its maximum, as the message shows. Swap the two values, such as `@price:[5 10]`. The same applies to `FILTER field min max`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_SYNTAX Invalid RADIUS value` | `RADIUS` in the `RANGE` arguments of `FT.HYBRID` must be a number of 0 or more. Correct the value, such as `RADIUS 0.5`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Invalid subqueries count: expected an unsigned integer` | After the index name, `FT.HYBRID` expects `SEARCH` or the number of subqueries, 2, but it got something else. Use `FT.HYBRID index [2] SEARCH query VSIM @field $param`. | `FT.HYBRID`, `FT.PROFILE` |
| `` SEARCH_SYNTAX Invalid value (<value>) for `<attribute>` `` | A query attribute has a value that it doesn't accept, as the message shows. `$weight` must be a number of 0 or more, `$slop` a whole number of -1 or more, and `$inorder` and `$phonetic` must be `true` or `false`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Invalid vector argument, expected a parameter name starting with $` | The query vector in the `VSIM` clause of `FT.HYBRID` must be a parameter, such as `$vec`, not the vector itself. Pass the vector bytes in `PARAMS`, such as `PARAMS 2 vec <vector-bytes>`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Invalid vector field for normalization` | `FT.HYBRID` couldn't find the `VECTOR` field of the `VSIM` clause when it prepared to normalize vector scores. An unknown field or a field of another type returns an earlier error, so this points to an internal problem. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_SYNTAX Minimum stem length cannot be lower than 2` | `MINSTEMLEN` can't be lower than 2. Set it to 2 or more; the default is 4, and values below 4 can slow down queries. | `FT.CONFIG SET` |
| `SEARCH_SYNTAX Missing @ prefix for vector field name` | The field after `VSIM` in `FT.HYBRID` must start with `@`, such as `@embedding`. Add the `@` before the name of the vector field. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Missing value for ALPHA` | `COMBINE LINEAR` in `FT.HYBRID` sets `BETA` but not `ALPHA`. Give both weights, such as `COMBINE LINEAR 4 ALPHA 0.7 BETA 0.3`, or neither to use the defaults. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Missing value for BETA` | `COMBINE LINEAR` in `FT.HYBRID` sets `ALPHA` but not `BETA`. Give both weights, such as `COMBINE LINEAR 4 ALPHA 0.7 BETA 0.3`, or neither to use the defaults. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Missing vector argument` | The `VSIM` clause of `FT.HYBRID` has a field but no query vector after it. Add the parameter that holds the vector, such as `VSIM @embedding $vec`, and define it in `PARAMS`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Missing vector field name` | `VSIM` is the last argument of `FT.HYBRID`, with no vector field or query vector after it. Add them, such as `VSIM @embedding $vec`, and define the parameter in `PARAMS`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Not enough arguments in <clause>, specified <number> but provided only <number>` | The count after `COMBINE RRF` or `COMBINE LINEAR` is larger than the number of arguments left in the command. The message shows both numbers. Make the count match the arguments that follow. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Not enough arguments in FILTER, specified <number> but provided only <number>` | The count after `FILTER` in the `VSIM` clause of `FT.HYBRID` is larger than the number of arguments left in the command. The message shows both numbers. Make the count match the filter expression and its options. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Parser stack overflow. Try moving nested parentheses more to the left` | Your query is nested too deeply for the query parser, whose stack holds 256 entries, for example with many levels of parentheses. Flatten the query, or put the nested groups earlier in the query string, as the message suggests. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Parsing/Syntax error for query string` | This is the default text of `SEARCH_SYNTAX`, which means that Redis Search couldn't parse the query string or the arguments of `FT.HYBRID`. Redis 8.10 sends a specific message instead, usually with the offset of the problem and the text near it. | Search queries |
| `SEARCH_SYNTAX SEARCH keyword is required` | After the number of subqueries, `FT.HYBRID` expects `SEARCH`, but it got something else. Use `FT.HYBRID index 2 SEARCH query VSIM @field $param`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SYNTAX Syntax error at offset <position> near <token>` | Redis Search couldn't parse your query string. The offset counts bytes from the start of the query, and the text after `near` shows where parsing stopped. Check there for an unbalanced parenthesis, bracket, or quote, a misplaced operator, or a special character that needs escaping. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Syntax error: Expecting a geoshape predicate at offset <position> near <token>` | Your shape query uses an operator that Redis Search doesn't support. In `@field:[operator $shape]`, the operator must be `WITHIN`, `CONTAINS`, `INTERSECTS`, or `DISJOINT`. The offset in the message points to the shape, not to the operator. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Syntax error: Expecting Vector Similarity command at offset <position> near <token>` | In the `=>[...]` part of your query, the first word must be `KNN`, but you wrote the word shown after `near`. Use the form `=>[KNN 10 @field $vector]`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_SYNTAX Syntax error: expecting vector similarity range command at offset <position> near <token>` | In a vector range query, `@field:[...]`, the first word must be `VECTOR_RANGE`, but you wrote the word shown after `near`. Use the form `@field:[VECTOR_RANGE 0.2 $vector]`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `` SEARCH_SYNTAX Unknown COMBINE method `<argument>` `` | `COMBINE` in `FT.HYBRID` names a method other than `RRF` or `LINEAR`. In Redis 8.10 you get `COMBINE: Invalid value for argument` for this instead, so you shouldn't see this message. Use `RRF` or `LINEAR`. | `FT.HYBRID`, `FT.PROFILE` |
| `` SEARCH_SYNTAX Unknown field `<field>` `` | The `VSIM` clause of `FT.HYBRID` names a field that isn't in the index. Check the name for typos, and run `FT.INFO` to see the `VECTOR` fields of the index. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_SYNTAX Unknown field at offset <position> near <token>` | Your query names a field, after `@`, that isn't in the index schema. The text after `near` is that name. Check its spelling, and use the alias if you defined the field with `AS`. `FT.INFO` lists the fields. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `` SEARCH_SYNTAX Use `INDEXEMPTY` in field creation in order to index and query for empty strings `` | The query searches for an empty string, such as `@title:""` or `@tags:{""}`, in a `TEXT` or `TAG` field created without `INDEXEMPTY`. Add `INDEXEMPTY` to that field. `FT.ALTER` can't change an existing field, so create the index again. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_SYNTAX VSIM argument is required` | `FT.HYBRID` reached the end of the command without finding the `VSIM` clause after `SEARCH`. Add `VSIM @field $param` after the query and its `SCORER` or `YIELD_SCORE_AS` options. | `FT.HYBRID`, `FT.PROFILE` |


### SEARCH_QUERY_STRING_BAD

No command in Redis 8.10 returns this code. Its default message is `Bad query string`. Most errors in the query string return [`SEARCH_SYNTAX`](#search_syntax) instead.

### SEARCH_KEYWORD

No command in Redis 8.10 returns this code. Its default message says that Redis Search couldn't handle a keyword in the query.

### SEARCH_FIELD_MISSING_REQ

No command in Redis 8.10 returns this code. When a query uses `ismissing()` on a field that wasn't defined with `INDEXMISSING`, you get [`SEARCH_SYNTAX`](#search_syntax) instead. To fix that error, add `INDEXMISSING` to the field when you create the index.

### SEARCH_ORDER_OPTION_BAD

The query uses `SLOP` or `INORDER` on a JSON text field whose JSONPath can return several values, for example a path with a wildcard. The order of those values isn't defined, so Redis Search can't apply `SLOP` or `INORDER` to them. To fix it, remove `SLOP` and `INORDER` from the query, or search only fields whose path leads to a single value or a single array. See [Index JSON arrays as TEXT](https://redis.io/docs/latest/develop/ai/search-and-query/indexing#index-json-arrays-as-text).

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_ORDER_OPTION_BAD Path with undefined ordering does not support slop/inorder` | You used `SLOP` or `INORDER` with a `TEXT` field of an `ON JSON` index whose path can match several values, such as `$..title`, so the order of words isn't defined. Remove `SLOP` and `INORDER`, or index a path that matches one value. Redis 8.10 also names the field. | Search queries |
| `` SEARCH_ORDER_OPTION_BAD slop/inorder are not supported for field with undefined ordering `<field>` `` | You used `SLOP` or `INORDER` on an `ON JSON` index with a `TEXT` field, named in the message, whose path can match several values, such as `$..title` or `$.tags[*]`. Word order across those values isn't defined. Remove `SLOP` and `INORDER`, or index a path that matches one value. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_PARAM_NOT_FOUND

The query uses a parameter, such as `$p`, that isn't defined in `PARAMS`. To fix it, add the parameter to `PARAMS`, or correct its name in the query.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_PARAM_NOT_FOUND Parameter not found` | Your query uses a parameter, such as `$vec`, that `PARAMS` doesn't define. Add it to `PARAMS`, or fix its name in the query. Redis 8.10 adds the parameter's name to this text. | Search queries |
| `` SEARCH_PARAM_NOT_FOUND Parameter not found `<parameter>` `` | The query uses a parameter, shown in the message, that `PARAMS` doesn't define. Add it to `PARAMS`, such as `PARAMS 2 p value`, or correct its name in the query. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |


### SEARCH_NO_RESULTS

No command in Redis 8.10 returns this code. A query that matches no documents returns an empty result, not an error.

### SEARCH_BUILD_PLAN

No command in Redis 8.10 returns this code. Its default message says that Redis Search couldn't build a plan for the query.

## Command arguments

### SEARCH_PARSE_ARGS

Redis Search couldn't parse the arguments of the command. This code covers more messages than any other, from many commands. The description after the code says which argument is wrong and why. Many descriptions start with the name of the argument, such as `LIMIT: Not enough arguments were provided`. To fix it, compare that argument with the syntax on the command's page, such as [`FT.SEARCH`](https://redis.io/docs/latest/commands/ft.search) or [`FT.CREATE`](https://redis.io/docs/latest/commands/ft.create).

| Error message | Explanation | Returned by |
|---|---|---|
| `` SEARCH_PARSE_ARGS 'Field cannot be defined with both `NOINDEX` and `INDEXMISSING` `<field>` ' `` | You defined a field with both `NOINDEX` and `INDEXMISSING`, and they conflict: `NOINDEX` keeps the field out of the index, so its missing values can't be searched either. Remove one of them from the field named in the message. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS <argument>: <reason>` | An argument of `FT.HYBRID`, named in the message, has a value of the wrong kind, such as a word where `TIMEOUT`, `DIALECT`, `ALPHA`, or `BETA` needs a number. The reason after the colon says what's wrong. Fix the value. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Argument specified multiple times` | An argument of `FT.HYBRID`, named in the message, appears more than once, such as two `LIMIT` clauses. Keep one. Only `APPLY` and `LOAD` can repeat. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Failed to parse past` | Redis Search couldn't move past the argument of `FT.HYBRID` named in the message. This internal check shouldn't fail after the argument was read. Compare the command with the `FT.HYBRID` syntax, and retry. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Failed to parse the argument count` | An argument of `FT.HYBRID` named in the message, such as `SORTBY` or `GROUPBY`, must be followed by the number of values that come next, and that number is missing or isn't valid. Add it, as in `SORTBY 2 @price DESC`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Invalid argument count` | The count after an argument of `FT.HYBRID`, named in the message, is out of range, such as `SORTBY 0`, which needs at least 1. Give the number of values that follow. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Invalid value for argument` | The argument named in the message has a value that `FT.HYBRID` doesn't accept. `COMBINE` takes `RRF` or `LINEAR`, `FORMAT` takes `STRING` or `EXPAND`, and `POLICY` in `FILTER` takes `ADHOC` or `BATCHES`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Not enough arguments were provided` | An argument of `FT.HYBRID` that takes a fixed number of values, named in the message, has fewer. For example, `LIMIT` needs both an offset and a count, as in `LIMIT 0 10`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Not enough arguments were provided based on argument count` | The count after an argument of `FT.HYBRID`, named in the message, is larger than the number of values that follow. For example, `SORTBY 3 @price` promises three values but gives one. Make the count match. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Required argument missing` | A required argument, named in the message, is missing. No argument of `FT.HYBRID` is marked as required in Redis Search 8.10, so you're unlikely to see this. Compare the command with the `FT.HYBRID` syntax. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Required positional argument missing or out of order` | A required argument that must come at a fixed position, named in the message, is missing or out of order. No argument of `FT.HYBRID` is like that in Redis Search 8.10, so you're unlikely to see this. Compare the command with the syntax. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Unknown argument` | `FT.HYBRID` doesn't recognize the argument shown in the message. Check its spelling, and that it's in the right place: options such as `LIMIT`, `SORTBY`, and `PARAMS` come after the `SEARCH` and `VSIM` clauses. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Unknown argument type` | The argument parser of Redis Search has no handler for the kind of argument named in the message. This is an internal error that the arguments that you send can't cause. Retry the command, and report it if it continues. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Unsupported target size for bitwise flag` | Redis Search couldn't store the flag named in the message because of an internal mismatch in its argument parser. The arguments that you send can't cause this. Retry the command, and report it if it continues. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Validation failed` | The value of the argument named in the message failed a check that gives no specific reason. No argument of `FT.HYBRID` uses such a check in Redis Search 8.10, so you're unlikely to see this. Compare the value with the command's syntax. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Value above maximum` | The value of the `FT.HYBRID` argument named in the message is too large. For example, `DIALECT` must be from 1 to 4. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Value below minimum` | The value of the `FT.HYBRID` argument named in the message is too small. For example, `DIALECT` must be from 1 to 4, and the `WINDOW` of `COMBINE` must be 1 or more. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Value must be non-negative` | The argument named in the message needs a value of 0 or more. No argument of `FT.HYBRID` uses this check in Redis Search 8.10, so you're unlikely to see this message. Check the value anyway. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <argument>: Value must be positive` | The argument named in the message needs a value greater than 0. No argument of `FT.HYBRID` uses this check in Redis Search 8.10, so you're unlikely to see this message. Check the value anyway. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS <clause> expects pairs of key value arguments, argument count must be an even number` | The count after `COMBINE RRF` or `COMBINE LINEAR`, named in the message, is odd. Its arguments come in name and value pairs, so the count must be even, such as `COMBINE LINEAR 4 ALPHA 0.7 BETA 0.3`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS _COORD_DISPATCH_TIME missing argument` | An internal query that the cluster coordinator sent to a shard has `_COORD_DISPATCH_TIME` without a value. You don't send this argument yourself, so this points to a problem inside the cluster. Run the query again, and report it to Redis if it continues. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS _COORD_DISPATCH_TIME requires a numeric value` | An internal query that the cluster coordinator sent to a shard has a `_COORD_DISPATCH_TIME` value that isn't a number. You don't send this argument yourself, so this points to a problem inside the cluster. Run the query again, and report it to Redis if it continues. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS _MAX_TRIM_DELAY_MS (<limit>) must be greater than _MIN_TRIM_DELAY_MS (<limit>)` | `_MAX_TRIM_DELAY_MS` must be larger than the current `_MIN_TRIM_DELAY_MS`, the second number in the message. These internal parameters start with an underscore and are normally left at their defaults. To lower both, lower `_MIN_TRIM_DELAY_MS` first. | `FT.CONFIG SET` |
| `SEARCH_PARSE_ARGS _MIN_TRIM_DELAY_MS (<limit>) must be less than _MAX_TRIM_DELAY_MS (<limit>)` | `_MIN_TRIM_DELAY_MS` must be smaller than the current `_MAX_TRIM_DELAY_MS`, the second number in the message. These internal parameters start with an underscore and are normally left at their defaults. To raise both, raise `_MAX_TRIM_DELAY_MS` first. | `FT.CONFIG SET` |
| `SEARCH_PARSE_ARGS _SLOTS_INFO already specified` | An internal query that the cluster coordinator sent to a shard has `_SLOTS_INFO` twice. You don't send this argument yourself, so this points to a problem inside the cluster. Run the query again, and report it to Redis if it continues. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS _SLOTS_INFO missing argument` | An internal query that the cluster coordinator sent to a shard has `_SLOTS_INFO` without a value. You don't send this argument yourself, so this points to a problem inside the cluster. Run the query again, and report it to Redis if it continues. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS ADDSCORES is not supported on FT.SEARCH` | `ADDSCORES` only works in `FT.AGGREGATE`, where it adds each document's score to the results as the `@__score` property. In `FT.SEARCH`, use `WITHSCORES` to get the scores instead. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `` SEARCH_PARSE_ARGS Alias for LOAD cannot be `AS` `` | In `LOAD`, the name after `AS` is the word `AS` itself, which usually means that an `AS` repeats or a name is missing. Give each loaded field a real name, such as `LOAD 3 @price AS cost`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `` SEARCH_PARSE_ARGS Alias for RETURN cannot be `AS` `` | In `RETURN`, you used `AS` as the new name of a field, as in `title AS AS`. Choose another name after `AS`, and check that the count after `RETURN` includes every field, every `AS`, and every new name. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS AS needs argument` | An `APPLY` step ends with `AS`, but no name follows it. Put the name for the result of the expression after `AS`, or remove `AS`, and the expression itself becomes the name. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS AS requires an argument` | `AS` is the last argument of your schema, with no alias after it. Write a field as `name AS alias TYPE`, or remove `AS`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Bad arguments for <argument>: <reason>` | The option or reducer named in the message has a missing or wrong value. The reason says which: `Expected an argument` means a value is missing, `Could not convert argument to expected type` means it isn't a number, and `Value is outside acceptable bounds` means it's out of range, as in `WITHCURSOR COUNT 0`. | `FT.AGGREGATE`, `FT.CONFIG SET`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for <geo property>: <reason>` | `GEOFILTER` couldn't read its first argument, the field name. The `<geo property>` in the message is literal text. In Redis 8.10 this can't happen once `GEOFILTER` has five arguments, so check the syntax `GEOFILTER field lon lat radius unit`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for <lat>: <reason>` | The latitude in `GEOFILTER`, its third argument, isn't a number. The `<lat>` in the message is literal text. Use the syntax `GEOFILTER field lon lat radius unit`, with the latitude as a number from -90 to 90. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for <lon>: <reason>` | The longitude in `GEOFILTER`, the argument after the field name, isn't a number. The `<lon>` in the message is literal text. Use the syntax `GEOFILTER field lon lat radius unit`, with the longitude as a number from -180 to 180. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for <radius>: <reason>` | The radius in `GEOFILTER`, the argument after the latitude, isn't a number. The `<radius>` in the message is literal text. Give a number greater than 0, followed by the unit: `m`, `km`, `mi`, or `ft`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for <resolution>: <reason>` | The optional third argument of the `QUANTILE` reducer, the resolution, isn't a whole number; `<resolution>` is the literal text of the message. Leave it out, as in `REDUCE QUANTILE 2 @price 0.5`, or give a whole number from 1 to 1000. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for <sample size>: <reason>` | The sample size of the `RANDOM_SAMPLE` reducer, its second argument, is missing or isn't a whole number; `<sample size>` is the literal text of the message. Give the property and then the number of values to sample, such as `REDUCE RANDOM_SAMPLE 2 @title 10`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for _INDEX_PREFIXES` | `_INDEX_PREFIXES` is an internal argument that the cluster coordinator adds when it sends `FT.HYBRID` to the shards. It isn't accepted from clients, and in Redis 8.10 reading it can't fail, so you shouldn't see this message. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Bad arguments for _REQUIRED_FIELDS: <reason>` | You passed `_REQUIRED_FIELDS`, an internal argument that the cluster uses between its nodes, with a missing or wrong count. Remove `_REQUIRED_FIELDS` from your command, because arguments that start with an underscore aren't meant for you to use. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for algorithm FLAT: <argument>` | Your `FLAT` vector field has an attribute, shown in the message, that `FLAT` doesn't accept. `FLAT` takes `TYPE`, `DIM`, `DISTANCE_METRIC`, `INITIAL_CAP`, and `BLOCK_SIZE`. Options such as `M` and `EF_CONSTRUCTION` belong to `HNSW`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Bad arguments for algorithm HNSW: <argument>` | Your `HNSW` vector field has an attribute, shown in the message, that `HNSW` doesn't accept. `HNSW` takes `TYPE`, `DIM`, `DISTANCE_METRIC`, `INITIAL_CAP`, `M`, `EF_CONSTRUCTION`, `EF_RUNTIME`, and `EPSILON`. Check the spelling, and that the count after `HNSW` is right. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Bad arguments for algorithm SVS-VAMANA: <argument>` | Your `SVS-VAMANA` vector field has an attribute, shown in the message, that it doesn't accept. It takes `TYPE`, `DIM`, `DISTANCE_METRIC`, `GRAPH_MAX_DEGREE`, `CONSTRUCTION_WINDOW_SIZE`, `COMPRESSION`, `SEARCH_WINDOW_SIZE`, `EPSILON`, `REDUCE`, and `TRAINING_THRESHOLD`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Bad arguments for APPLY/FILTER: <reason>` | `APPLY` or `FILTER` is the last argument of `FT.AGGREGATE`, with no expression after it. Put the expression right after the keyword, as one quoted argument, such as `FILTER "@price > 100"`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for AS: <reason>` | A `REDUCE` step ends with `AS`, but no name follows it. Put the name for the reducer's result after `AS`, or remove `AS` to let Redis Search generate a name. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for COLLECT: <error>` | The arguments of the `COLLECT` reducer don't match its syntax, and the text after the colon names the option and the problem. Common causes are a missing `FIELDS`, which must come first, an unknown word, a `SORTBY` count of 0 or over 16, and a `LIMIT` with fewer than two values. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for GROUPBY: <reason>` | The count after `GROUPBY` is missing, isn't a number, is larger than the number of arguments that follow, or is over 65535; the reason says which. Write `GROUPBY`, the number of properties, and then the properties, each starting with `@`, such as `GROUPBY 1 @city`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for GROUPBY: Expected at least one property` | `GROUPBY` in `FT.HYBRID` has a count of 0, so it names no properties to group by. Give the count and at least one property, such as `GROUPBY 1 @category`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Bad arguments for GROUPBY: Failed to parse property <position>, <reason>` | `FT.HYBRID` couldn't read one of the properties after `GROUPBY`, and the number is its position, counting from 1. In Redis 8.10 this can't happen once the count is valid, so check that the count matches the properties that follow. | `FT.HYBRID`, `FT.PROFILE` |
| `` SEARCH_PARSE_ARGS Bad arguments for GROUPBY: Unknown property `<property>`. Did you mean `@<property>`? `` | A property after `GROUPBY` doesn't start with `@`. Write each property with `@` in front of its name, as the message suggests. If the property in the message is a keyword such as `REDUCE`, the count after `GROUPBY` is larger than the number of properties. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for HIGHLIGHT` | Redis Search couldn't parse the options of `HIGHLIGHT`. Check that `FIELDS` is followed by the number of fields and then the fields, and that `TAGS` is followed by both an opening and a closing tag, such as `HIGHLIGHT FIELDS 1 title TAGS <b> </b>`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for LOAD: <reason>` | `LOAD` is the last argument with no count after it, or its count is larger than the number of fields that follow. Write `LOAD`, the number of fields, and then the fields, such as `LOAD 2 @title @price`, or use `LOAD *` to load all fields. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `` SEARCH_PARSE_ARGS Bad arguments for LOAD: Expected number of fields or `*` `` | The argument after `LOAD` is neither a number nor `*`. Write the number of fields to load first, such as `LOAD 2 @title @price`, or use `LOAD *` to load all fields. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for MAX: <reason>` | The value after `MAX` in the `SORTBY` step of `FT.AGGREGATE` is missing or isn't a whole number. Give `MAX` the number of sorted results to keep, such as `SORTBY 2 @price DESC MAX 10`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for PARAMS: <reason>` | The count after `PARAMS` isn't a number, or it's larger than the number of arguments that follow. `PARAMS` takes a count and then that many arguments, as name and value pairs, such as `PARAMS 4 lon -122.4 lat 37.7`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_PARSE_ARGS Bad arguments for REDUCE: <reason>` | `REDUCE` is the last argument, with no reducer after it. The reason in the message doesn't help here (it can say `SUCCESS`). Write the reducer name, its argument count, and its arguments, such as `REDUCE COUNT 0 AS total`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for SORTBY: <reason>` | The count after `SORTBY` in `FT.AGGREGATE` is missing, isn't a number, or is larger than the number of arguments that follow. The count includes every property and every `ASC` or `DESC`, so `SORTBY 2 @price DESC` has a count of 2. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for SUMMARIZE` | Redis Search couldn't parse the options of `SUMMARIZE`. Check that `FIELDS` is followed by the number of fields and then the fields, that `LEN` and `FRAGS` have whole numbers, and that `SEPARATOR` has a value, such as `SUMMARIZE FIELDS 1 body FRAGS 2 LEN 20`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad arguments for vector similarity algorithm: <reason>` | After `VECTOR` in your schema, the algorithm is missing or isn't one that Redis Search knows. Use `FLAT`, `HNSW`, or `SVS-VAMANA`, followed by the number of attribute arguments. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity FLAT index `BLOCK_SIZE`: <reason> `` | The `BLOCK_SIZE` value of your `FLAT` vector field isn't valid: it must be a whole number of 1 or more. Redis Search no longer uses `BLOCK_SIZE`, so you can also leave it out. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity FLAT index `DIM`: <reason> `` | The `DIM` value of your `FLAT` vector field isn't valid, or it's missing. It must be a whole number of 1 or more, equal to the number of elements in each vector. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity FLAT index `DISTANCE_METRIC`: <reason> `` | The `DISTANCE_METRIC` of your `FLAT` vector field isn't valid, or it has no value. Use `L2`, `IP`, or `COSINE`. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity FLAT index `INITIAL_CAP`: <reason> `` | The `INITIAL_CAP` value of your `FLAT` vector field isn't valid. It must be a whole number of 0 or more: the number of vectors to reserve space for. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity FLAT index `TYPE`: <reason> `` | The `TYPE` of your `FLAT` vector field isn't a supported data type, or it has no value. Use `FLOAT32`, `FLOAT64`, `FLOAT16`, `BFLOAT16`, `INT8`, or `UINT8`. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity HNSW index `DIM`: <reason> `` | The `DIM` value of your `HNSW` vector field isn't valid, or it's missing. It must be a whole number of 1 or more, equal to the number of elements in each vector. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity HNSW index `DISTANCE_METRIC`: <reason> `` | The `DISTANCE_METRIC` of your `HNSW` vector field isn't valid, or it has no value. Use `L2`, `IP`, or `COSINE`. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity HNSW index `EF_CONSTRUCTION`: <reason> `` | The `EF_CONSTRUCTION` value of your `HNSW` vector field isn't valid. It must be a whole number of 1 or more; higher values build a more accurate graph, more slowly. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity HNSW index `EF_RUNTIME`: <reason> `` | The `EF_RUNTIME` value of your `HNSW` vector field isn't valid. It must be a whole number of 1 or more: the default number of candidates that a `KNN` query examines. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity HNSW index `EPSILON`: <reason> `` | The `EPSILON` value of your `HNSW` vector field isn't valid. It must be a number of 0 or more; it widens the search boundary of vector range queries. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity HNSW index `INITIAL_CAP`: <reason> `` | The `INITIAL_CAP` value of your `HNSW` vector field isn't valid. It must be a whole number of 0 or more: the number of vectors to reserve space for. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity HNSW index `M`: <reason> `` | The `M` value of your `HNSW` vector field isn't valid, or it's missing. It must be a whole number of 1 or more: the maximum number of connections of each node in the graph. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity HNSW index `TYPE`: <reason> `` | The `TYPE` of your `HNSW` vector field isn't a supported data type, or it has no value. Use `FLOAT32`, `FLOAT64`, `FLOAT16`, `BFLOAT16`, `INT8`, or `UINT8`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Bad arguments for vector similarity number of parameters: <reason>` | The number after the vector algorithm, which counts the attribute arguments that follow, isn't a valid number. Give the count of names and values, as in `HNSW 6 TYPE FLOAT32 DIM 128 DISTANCE_METRIC COSINE`. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity SVS-VAMANA index `COMPRESSION`: <reason> `` | The `COMPRESSION` value of your `SVS-VAMANA` vector field isn't supported. Use `LVQ8`, `LVQ4`, `LVQ4x4`, `LVQ4x8`, `LeanVec4x8`, or `LeanVec8x8`; case doesn't matter. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity SVS-VAMANA index `CONSTRUCTION_WINDOW_SIZE`: <reason> `` | The `CONSTRUCTION_WINDOW_SIZE` value of your `SVS-VAMANA` vector field isn't valid. It must be a whole number of 1 or more. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity SVS-VAMANA index `DIM`: <reason> `` | The `DIM` value of your `SVS-VAMANA` vector field isn't valid, or it's missing. It must be a whole number of 1 or more, equal to the number of elements in each vector. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity SVS-VAMANA index `DISTANCE_METRIC`: <reason> `` | The `DISTANCE_METRIC` of your `SVS-VAMANA` vector field isn't valid, or it has no value. Use `L2`, `IP`, or `COSINE`. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity SVS-VAMANA index `EPSILON`: <reason> `` | The `EPSILON` value of your `SVS-VAMANA` vector field isn't valid. It must be a number of 0 or more; it widens the search boundary of vector range queries. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity SVS-VAMANA index `GRAPH_MAX_DEGREE`: <reason> `` | The `GRAPH_MAX_DEGREE` value of your `SVS-VAMANA` vector field isn't valid. It must be a whole number of 1 or more: the maximum number of edges of each node in the graph. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity SVS-VAMANA index `REDUCE`: <reason> `` | The `REDUCE` value of your `SVS-VAMANA` vector field isn't valid. It must be a whole number of 1 or more: the reduced dimension that `LeanVec` compression uses. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity SVS-VAMANA index `SEARCH_WINDOW_SIZE`: <reason> `` | The `SEARCH_WINDOW_SIZE` value of your `SVS-VAMANA` vector field isn't valid. It must be a whole number of 1 or more. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity SVS-VAMANA index `TRAINING_THRESHOLD`: <reason> `` | The `TRAINING_THRESHOLD` value of your `SVS-VAMANA` vector field isn't a valid whole number. It must be at least 1,024, and it applies only when you set `COMPRESSION`. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Bad arguments for vector similarity SVS-VAMANA index `TYPE`: <reason> `` | The `TYPE` of your `SVS-VAMANA` vector field isn't a known data type, or it has no value. `SVS-VAMANA` supports only `FLOAT32` and `FLOAT16`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Bad arguments for vector similarity: not enough arguments` | The count after `HNSW` is larger than the number of arguments left in the command. Make the count match the names and values that follow, as in `HNSW 6 TYPE FLOAT32 DIM 128 DISTANCE_METRIC COSINE`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Bad arguments for weight: <reason>` | The `WEIGHT` value of a `TEXT` field isn't a number, or it's missing. Give a number such as `WEIGHT 2.0`; it scales how much matches in this field add to a document's score. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Bad format string!` | The format string of `format()` ends with a single `%`. Write `%s` for each value to insert, and `%%` for a literal percent sign. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Bad lower range: <argument>` | The minimum of a numeric range, shown in the message, isn't a number. It comes from `FILTER field min max` in `FT.SEARCH`, or from a parameter such as `@price:[$min 100]`. Use a number, `-inf`, or `inf`, optionally after `(` to exclude the bound. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_PARSE_ARGS Bad number of arguments for vector similarity index: got <number> but expected even number as algorithm parameters (should be submitted as named arguments)` | The count after `FLAT` or `SVS-VAMANA`, shown in the message, is odd. Attributes come in name and value pairs, so count both, as in `FLAT 6 TYPE FLOAT32 DIM 128 DISTANCE_METRIC L2`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Bad SORTBY arguments` | `SORTBY` in `FT.SEARCH` has no field after it. Give one field to sort by, optionally followed by `ASC` or `DESC`, such as `SORTBY price DESC`. The field must be in the index. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Bad upper range: <argument>` | The maximum of a numeric range, shown in the message, isn't a number. It comes from `FILTER field min max` in `FT.SEARCH`, or from a parameter such as `@price:[0 $max]`. Use a number, `-inf`, or `inf`, optionally after `(` to exclude the bound. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `` SEARCH_PARSE_ARGS Bad value for COUNT: `<argument>` `` | In a cluster, the value after `COUNT` in `FT.CURSOR READ` isn't an integer, and the message shows what you passed. Give `COUNT` a whole number: the number of results to read in this call. | `FT.CURSOR READ` |
| `SEARCH_PARSE_ARGS BM25STD_TANH_FACTOR must be between 1 and 10000 inclusive` | The value of `BM25STD_TANH_FACTOR` in the query isn't a whole number of 1 or more. This option sets how the `BM25STD.TANH` scorer normalizes scores; give it an integer from 1 to 10000. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Could not convert argument to expected type` | The value that you gave to `FT.CONFIG SET` isn't a number, but this parameter needs one. Give a whole number, such as `FT.CONFIG SET TIMEOUT 1000`. | `FT.CONFIG SET` |
| `` SEARCH_PARSE_ARGS Could not parse schema for field `<field>` `` | Redis Search couldn't parse the definition of the field named in the message and has no more specific reason. Check the field's type and options against the `FT.CREATE` syntax, and for an `ON JSON` index, check the field's path. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Count accepts 0 values only` | In a cluster, the `COUNT` reducer has arguments, but it doesn't take any. Write `REDUCE COUNT 0`, optionally followed by `AS` and a name. | `FT.AGGREGATE`, `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS DIALECT is not supported in FT.HYBRID or any of its subqueries. Please check the documentation on search-default-dialect configuration.` | `FT.HYBRID` doesn't accept `DIALECT`, either at the end or in its `SEARCH` or `VSIM` clause. It uses the dialect of the `search-default-dialect` configuration parameter, and at least dialect 2, so remove `DIALECT` from the command. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS DIALECT requires a non negative integer >=1 and <= 4` | The value after `DIALECT` isn't a whole number from 1 to 4. Use a dialect from 1 to 4, or leave out `DIALECT` to use the `search-default-dialect` setting. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_PARSE_ARGS Error parsing arguments` | You only get this in a cluster, where the coordinator reads the arguments of `FT.SEARCH` before it sends the query to the shards. It couldn't read one of the arguments, so check them against the `FT.SEARCH` syntax. | `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Error parsing arguments: <reason>` | Redis Search couldn't read the options that follow the prefix in `FT.SUGGET`, and the reason in the message says why. You rarely see this message, because a wrong option usually gets a more specific error. Compare your options with the `FT.SUGGET` syntax: `FUZZY`, `MAX`, `WITHSCORES`, and `WITHPAYLOADS`. | `FT.SUGGET` |
| `SEARCH_PARSE_ARGS Error parsing query/aggregation arguments` | This is the default text of `SEARCH_PARSE_ARGS`, which means that Redis Search couldn't parse the arguments of the command. Redis 8.10 sends a specific message that names the argument instead. Compare the arguments with the command's syntax. | Redis Search commands |
| `SEARCH_PARSE_ARGS Expected <number> parameters but got <number>` | The count after `FLAT` or `SVS-VAMANA` is larger than the number of attribute arguments that follow. The message shows both numbers. Make the count match the names and values. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Expected an argument, but none provided` | `FT.CONFIG SET` got a parameter name but no value after it. Add the value, such as `FT.CONFIG SET TIMEOUT 1000`. | `FT.CONFIG SET` |
| `` SEARCH_PARSE_ARGS Expected number of fields or `*` after FIELDS `` | The word after `FIELDS` in the `COLLECT` reducer is neither a number nor `*`. Write the number of fields and then the fields, such as `FIELDS 2 @title @price`, or use `FIELDS *`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS EXPLAINSCORE is not supported with GROUPBY` | `FT.HYBRID` can't explain the scores of grouped results, because `GROUPBY` replaces the documents with groups that have no score explanation. Remove `EXPLAINSCORE` or `GROUPBY`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS EXPLAINSCORE must be accompanied with WITHSCORES` | You used `EXPLAINSCORE` without `WITHSCORES`. Add `WITHSCORES`, because the explanation is returned together with each document's score. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Failed to create argument parser` | `FT.HYBRID` couldn't create the parser for its optional arguments, such as `LIMIT` and `SORTBY`. This only happens if a memory allocation fails, which normally stops Redis instead, so you shouldn't see this message. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Failed to create argument parser for COLLECT` | Redis Search couldn't set up the parser for the arguments of the `COLLECT` reducer. This is an internal error that shouldn't happen, not a problem with your command. Run the query again, and report it to Redis if it repeats. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Failed to create argument parser for FILTER` | `FT.HYBRID` couldn't create the parser for the options of `FILTER` in the `VSIM` clause. This only happens if a memory allocation fails, which normally stops Redis instead, so you shouldn't see this message. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Failed to create LINEAR argument parser` | `FT.HYBRID` couldn't create the parser for the arguments of `COMBINE LINEAR`. This only happens if a memory allocation fails, which normally stops Redis instead, so you shouldn't see this message. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Failed to create parameter dictionary` | `FT.HYBRID` couldn't allocate the table that holds the `PARAMS` values. This only happens if a memory allocation fails, which normally stops Redis instead, so you shouldn't see this message. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Failed to create RRF argument parser` | `FT.HYBRID` couldn't create the parser for the arguments of `COMBINE RRF`. This only happens if a memory allocation fails, which normally stops Redis instead, so you shouldn't see this message. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Failed to deserialize _SLOTS_INFO data` | A shard couldn't read the hash slot information (`_SLOTS_INFO`) that the cluster coordinator adds to the queries it sends to the shards. You don't send this argument yourself, so this is an internal error inside the cluster. Run the query again, and report it to Redis if it continues. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Failed to read argument` | Redis Search couldn't read the next argument of `FT.HYBRID` as text. This internal check shouldn't fail for arguments that a client sends. Compare the command with the `FT.HYBRID` syntax, and retry. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `` SEARCH_PARSE_ARGS Field `<field>` does not have a type `` | A field in your schema has no type after its name, or Redis Search read a misplaced option as a new field name, such as `INDEXMISSING` after `SORTABLE`. The message shows that name. Put the type right after the name, and the options in the order that `FT.CREATE` shows. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Fields arguments are missing` | `FT.CREATE` has `SCHEMA` with no fields after it. Add at least one field, such as `SCHEMA title TEXT`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS FILTER requires 3 arguments` | The `FILTER` argument of `FT.SEARCH` needs three arguments: the field, the minimum, and the maximum. Add the missing ones, such as `FILTER price 10 100`, or use a numeric range in the query, such as `@price:[10 100]`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS FORMAT <argument> is not supported` | `FORMAT` accepts only `STRING` or `EXPAND`, and the message shows the value that you gave. Use `FORMAT STRING` for the default output, or `FORMAT EXPAND` to get JSON values as structured data. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS FT.HYBRID currently supports only two subqueries` | The number after the index name in `FT.HYBRID` is the number of subqueries, and it must be 2: one `SEARCH` and one `VSIM`. Use `FT.HYBRID index 2 SEARCH ... VSIM ...`, or leave the number out. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Geo coordinates must be finite` | A document's `GEO` field has a coordinate that is infinite or not a number, such as `inf` or `nan`, so Redis Search doesn't index the document. `FT.INFO` reports it. Store the location as `longitude,latitude` with finite numbers. | `FT.ALTER`, `FT.CREATE`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS GEOFILTER requires 5 arguments` | `GEOFILTER` needs five arguments: the field, the longitude, the latitude, the radius, and the unit. The command ends before all five, so add the missing ones, for example `GEOFILTER location -122.41 37.77 5 km`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS HIGHLIGHT is not supported on FT.AGGREGATE` | `HIGHLIGHT` only works in `FT.SEARCH`. Run the query with `FT.SEARCH` to highlight the matching terms, or remove `HIGHLIGHT` from `FT.AGGREGATE`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Index name was not given to upgrade argument` | The `UPGRADE_INDEX` module argument has no index name after it. Redis Search reads `UPGRADE_INDEX` only when it loads, so this message appears in the Redis log and the module doesn't load. Add the index name in the module arguments. | `FT.CONFIG SET` |
| `SEARCH_PARSE_ARGS Invalid <clause> argument count, error: <reason>` | The argument after `COMBINE RRF` or `COMBINE LINEAR`, named in the message, must be the count of the arguments that follow, but it isn't a whole number of 0 or more. Add the count, such as `COMBINE RRF 2 CONSTANT 60`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Invalid argument count: expected an unsigned integer` | The argument after `KNN` or `RANGE` in the `VSIM` clause of `FT.HYBRID` must be the count of the arguments that follow, but it isn't a whole number. Add the count, such as `KNN 2 K 10` or `RANGE 2 RADIUS 0.5`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Invalid arguments for reducer <reducer>` | In a cluster, the reducer in the message has the wrong number of arguments. `SUM`, `MIN`, `MAX`, `AVG`, `TOLIST`, `STDDEV`, and `COUNT_DISTINCTISH` take exactly 1, and `QUANTILE` takes exactly 2, so its optional resolution argument isn't supported in a cluster. | `FT.AGGREGATE`, `FT.HYBRID`, `FT.PROFILE` |
| `` SEARCH_PARSE_ARGS Invalid field type for field `<field>` `` | The type after a field name in your schema isn't one that Redis Search knows, or an extra argument was read as a field name. Use `TEXT`, `TAG`, `NUMERIC`, `GEO`, `GEOSHAPE`, or `VECTOR`, and check that the count after a vector algorithm covers all its attributes. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Invalid filter-expression for FILTER` | `FT.HYBRID` couldn't read the filter expression after `FILTER` in the `VSIM` clause. In Redis 8.10 a `FILTER` without an expression returns `Missing argument count for FILTER` instead, so you shouldn't see this message. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Invalid GC Policy value` | `GC_POLICY` accepts only `FORK` or `DEFAULT`. You can set it only when Redis Search loads, so this message appears in the Redis log and the module doesn't load. Fix the value in the module arguments. | `FT.CONFIG SET` |
| `SEARCH_PARSE_ARGS Invalid geo string "<value>": <reason>` | A document's `GEO` field has a longitude or latitude that isn't a number; the message shows that part and why it failed. Redis Search doesn't index the document, and `FT.INFO` reports it. Store the location as `longitude,latitude`, such as `-122.41,37.77`. | `FT.ALTER`, `FT.CREATE`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid geo string: missing separator` | A document's `GEO` field has no comma or space between longitude and latitude, so Redis Search can't read it and doesn't index the document. `FT.INFO` reports it. Store the location as `longitude,latitude` or `longitude latitude`. | `FT.ALTER`, `FT.CREATE`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid geo string: not valid UTF-8` | A document's `GEO` field contains bytes that aren't valid Unicode text, so Redis Search can't read the coordinates and doesn't index the document. `FT.INFO` reports it. Store the location as plain text, such as `-122.41,37.77`. | `FT.ALTER`, `FT.CREATE`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid LIMIT offset + count value` | The offset plus the count in the `LIMIT` of the `COLLECT` reducer is too large for Redis Search to handle. Use smaller values: each one must also be within `search-max-aggregate-results`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Invalid resolution` | The resolution of the `QUANTILE` reducer, its optional third argument, isn't between 1 and 1000. Use a value in that range, or leave it out to use the default of 500. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Invalid TRAINING_THRESHOLD: cannot be lower than DEFAULT_BLOCK_SIZE (<number>)` | The `TRAINING_THRESHOLD` of your `SVS-VAMANA` vector field is below 1,024, the minimum shown in the message. Set it to 1,024 or more, or leave it out to use the default. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 0 in function 'contains'. VALIDATE_ARG__STRING(v, 0) was false.` | The first argument of `contains()` isn't a string; the number in parentheses is its type, such as 1 for a number. Pass the text to search in first and the substring second, both as strings. The `VALIDATE_ARG__STRING(v, 0)` part is internal. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 0 in function 'format'. VALIDATE_ARG__STRING(v, 0) was false.` | The first argument of `format()`, the format string, isn't a string; the number in parentheses is its type, such as 1 for a number. Put a quoted format string first, such as `format("%s-%s", @a, @b)`. The `VALIDATE_ARG__STRING(v, 0)` part is internal. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 0 in function 'parsetime'. VALIDATE_ARG__STRING(v, 0) was false.` | The first argument of `parsetime()` isn't a string; the number in parentheses is its type, such as 1 for a number. Pass the date text first and the format second, such as `parsetime(@date, "%Y-%m-%d")`. The `VALIDATE_ARG__STRING(v, 0)` part is internal. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 0 in function 'split'. VALIDATE_ARG__STRING(v, 0) was false.` | The first argument of `split()` isn't a string; the number in parentheses is its type, such as 1 for a number. Pass the text to split as the first argument. The `VALIDATE_ARG__STRING(v, 0)` part is internal. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 0 in function 'startswith'. VALIDATE_ARG__STRING(v, 0) was false.` | The first argument of `startswith()` isn't a string; the number in parentheses is its type, such as 1 for a number. Pass the text to check first and the prefix second, both as strings. The `VALIDATE_ARG__STRING(v, 0)` part is internal. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 0 in function 'strlen'. VALIDATE_ARG__STRING(v, 0) was false.` | The argument of `strlen()` isn't a string; the number in parentheses is its type, such as 1 for a number, which you get from a `NUMERIC` field. Use `strlen()` only on text. The `VALIDATE_ARG__STRING(v, 0)` part is internal. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 1 in function 'contains'. VALIDATE_ARG__STRING(v, 0) was false.` | The second argument of `contains()`, the substring to look for, isn't a string; the number in parentheses is its type, such as 1 for a number. Pass it as a quoted string. The `VALIDATE_ARG__STRING(v, 0)` part is internal and doesn't mean the first argument. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 1 in function 'parsetime'. VALIDATE_ARG__STRING(v, 0) was false.` | The second argument of `parsetime()`, the format, isn't a string; the number in parentheses is its type, such as 1 for a number. Pass the format as a quoted string, such as `parsetime(@date, "%Y-%m-%d")`. The `VALIDATE_ARG__STRING(v, 0)` part is internal and doesn't mean the first argument. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 1 in function 'split'. VALIDATE_ARG__STRING(v, 0) was false.` | The second argument of `split()`, the separator characters, isn't a string; the number in parentheses is its type, such as 1 for a number. Pass the separators as a quoted string, such as `split(@tags, ",")`. The `VALIDATE_ARG__STRING(v, 0)` part is internal. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 1 in function 'startswith'. VALIDATE_ARG__STRING(v, 0) was false.` | The second argument of `startswith()`, the prefix, isn't a string; the number in parentheses is its type, such as 1 for a number. Pass the prefix as a quoted string. The `VALIDATE_ARG__STRING(v, 0)` part is internal and doesn't mean the first argument. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 1 in function 'substr'. VALIDATE_ARG__TYPE(v, RSValueType_Number) was false.` | The second argument of `substr()`, the offset, isn't a number; the number in parentheses is its type, such as 2 for a string. Pass the offset as a number without quotes, such as `substr(@title, 0, 5)`. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 1 in function 'time'. VALIDATE_ARG__TYPE(v, RSValueType_String) was false.` | The second argument of `timefmt()`, the format, isn't a string; the message calls the function `time`, and the number in parentheses is the type that you passed, such as 1 for a number. Pass the format as a quoted string, such as `timefmt(@ts, "%Y-%m-%d")`. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 2 in function 'split'. VALIDATE_ARG__STRING(v, 0) was false.` | The third argument of `split()`, the characters to trim from each part, isn't a string; the number in parentheses is its type, such as 1 for a number. Pass it as a quoted string, such as `split(@tags, ",", " ")`. The `VALIDATE_ARG__STRING(v, 0)` part is internal. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type (<value_type>) for argument 2 in function 'substr'. VALIDATE_ARG__TYPE(v, RSValueType_Number) was false.` | The third argument of `substr()`, the length, isn't a number; the number in parentheses is its type, such as 2 for a string. Pass the length as a number without quotes, such as `substr(@title, 0, 5)`. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalid type for substr. Expected string` | The first argument of `substr()` isn't a string, for example because it's a number. Pass the text to cut as the first argument, such as `substr(@title, 0, 5)`. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Invalie MT mode` | `MT_MODE` accepts only `MT_MODE_OFF`, `MT_MODE_ONLY_ON_OPERATIONS`, or `MT_MODE_FULL`, and you can set it only when Redis Search loads. `MT_MODE` is deprecated, so remove it from the module arguments and use `WORKERS` instead. | `FT.CONFIG SET` |
| `SEARCH_PARSE_ARGS Legacy GC policy is no longer supported (since 2.6.0)` | `GC_POLICY LEGACY` was removed in Redis Search 2.6.0, and only `FORK` is left. Remove `GC_POLICY LEGACY` from the module arguments, or change it to `GC_POLICY FORK`. | `FT.CONFIG SET` |
| `SEARCH_PARSE_ARGS LIMIT count must be a non-negative integer` | The second argument of `LIMIT` in `FT.HYBRID`, the number of results, isn't a whole number of 0 or more. Use `LIMIT offset num`, such as `LIMIT 0 10`. A `LIMIT` with only one number also reads the next keyword as the count. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS LIMIT count must be a positive integer` | The count in the `LIMIT` of the `COLLECT` reducer is 0, negative, or not a number. Give a count of 1 or more. To count the documents of each group without collecting them, use the `COUNT` reducer. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS LIMIT needs two numeric arguments` | The offset or the count after `LIMIT` isn't a whole number of 0 or more. Give `LIMIT` two whole numbers, the offset first and then the count, such as `LIMIT 0 10`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS LIMIT offset + count overflow` | The offset plus the count in `LIMIT` of `FT.HYBRID` is greater than 9223372036854775807, the largest value Redis Search can handle. Use a smaller offset. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS LIMIT offset must be a non-negative integer` | The offset in `LIMIT` isn't a whole number of 0 or more. This message comes from the `LIMIT` of `FT.HYBRID` or of the `COLLECT` reducer. Give the offset first and the count second, such as `LIMIT 0 10`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS LIMIT requires 2 arguments` | `LIMIT` in `FT.HYBRID` needs two arguments, the offset and the number of results. In Redis 8.10 a short `LIMIT` returns `LIMIT: Not enough arguments were provided` instead, so you shouldn't see this message. Use `LIMIT 0 10`, for example. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS LIMIT requires two arguments` | `LIMIT` has fewer than two values after it. Give both the offset and the count, such as `LIMIT 0 10` for the first 10 results. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS LOAD path AS name - must be accompanied with NAME` | In `LOAD`, `AS` is the last argument that the count covers, with no name after it. Add the name, and include it in the count, such as `LOAD 3 @price AS cost`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Max depth for range cannot be higher than max depth for balance` | `_NUMERIC_RANGES_PARENTS` is over 2, the largest value that it accepts. This internal parameter is normally left at its default of 0; set it to 0, 1, or 2. | `FT.CONFIG SET` |
| `SEARCH_PARSE_ARGS MAX: <reason>` | The `MAX` value of `FT.SUGGET` isn't valid. It must be a whole number of 1 or more: the most suggestions to return. | `FT.SUGGET` |
| `SEARCH_PARSE_ARGS Memory allocation failed for error message` | `FT.HYBRID` found a problem in its arguments, but Redis Search ran out of memory while it wrote the description. Free memory on the server, and then run the command again to see the real error. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Missing <clause> argument count` | `COMBINE RRF` or `COMBINE LINEAR`, named in the message, ends the command, but a count of the arguments that follow is required. Add it, such as `COMBINE RRF 2 CONSTANT 60`, or `COMBINE RRF 0` for the default settings. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Missing argument count` | `KNN` or `RANGE` is the last argument of the `VSIM` clause in `FT.HYBRID`, but a count and its arguments must follow. Add them, such as `KNN 2 K 10` or `RANGE 2 RADIUS 0.5`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Missing argument count for FILTER` | `FILTER` is the last argument of the `VSIM` clause in `FT.HYBRID`, with nothing after it. Add the filter expression, optionally after the count of the arguments that follow, such as `FILTER 1 @category:{books}`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Missing argument value for <argument>` | In the `VSIM` clause of `FT.HYBRID`, the argument named in the message, such as `K` or `RADIUS`, ends the command with no value after it. Add its value, and check that the count after `KNN` or `RANGE` matches. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Missing argument value for SHARD_K_RATIO` | `SHARD_K_RATIO` in the `KNN` arguments of `FT.HYBRID` ends the command with no value after it. Add a number greater than 0 and at most 1, such as `SHARD_K_RATIO 0.5`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Missing argument value for YIELD_SCORE_AS` | `YIELD_SCORE_AS` is the last argument of `FT.HYBRID`, with no name after it. Add the name to give the score, such as `YIELD_SCORE_AS vector_score`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Missing arguments for <reducer>` | The reducer in the message needs a property, but its argument count is 0, as in `REDUCE SUM 0`. Give the count and the property, such as `REDUCE SUM 1 @price`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS MISSING ASC or DESC after sort field (<argument>)` | In the `SORTBY` step of `FT.AGGREGATE`, the word in parentheses is neither a property nor `ASC` or `DESC`. Properties need `@` in front of their names, as in `SORTBY 2 @title ASC`, and the count after `SORTBY` must include every property and every `ASC` or `DESC`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Missing field name in SORTBY` | `SORTBY` in `FT.HYBRID` has no field name where one is expected. In Redis 8.10 the count after `SORTBY` already makes sure a field follows, so you shouldn't see this message. Use `SORTBY count @field [ASC\|DESC]`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Missing filter-expression for FILTER` | `FILTER` in the `VSIM` clause of `FT.HYBRID` has a count of 0, so it has no filter expression. Set the count to the number of arguments that follow, such as `FILTER 1 @category:{books}`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Missing mandatory parameter: cannot create FLAT index without specifying DIM argument` | Your `FLAT` vector field doesn't set `DIM`, which is required. Add `DIM` with the number of elements in each vector, and count it in the number after `FLAT`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Missing mandatory parameter: cannot create FLAT index without specifying DISTANCE_METRIC argument` | Your `FLAT` vector field doesn't set `DISTANCE_METRIC`, which is required. Add `DISTANCE_METRIC` with `L2`, `IP`, or `COSINE`, and count it in the number after `FLAT`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Missing mandatory parameter: cannot create FLAT index without specifying TYPE argument` | Your `FLAT` vector field doesn't set `TYPE`, which is required. Add a type such as `TYPE FLOAT32`, and count it in the number after `FLAT`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Missing mandatory parameter: cannot create HNSW index without specifying DIM argument` | Your `HNSW` vector field doesn't set `DIM`, which is required. Add `DIM` with the number of elements in each vector, and count it in the number after `HNSW`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Missing mandatory parameter: cannot create HNSW index without specifying DISTANCE_METRIC argument` | Your `HNSW` vector field doesn't set `DISTANCE_METRIC`, which is required. Add `DISTANCE_METRIC` with `L2`, `IP`, or `COSINE`, and count it in the number after `HNSW`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Missing mandatory parameter: cannot create HNSW index without specifying TYPE argument` | Your `HNSW` vector field doesn't set `TYPE`, which is required. Add a type such as `TYPE FLOAT32`, and count it in the number after `HNSW`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Missing mandatory parameter: cannot create SVS-VAMANA index without specifying DIM argument` | Your `SVS-VAMANA` vector field doesn't set `DIM`, which is required. Add `DIM` with the number of elements in each vector, and count it in the number after `SVS-VAMANA`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Missing mandatory parameter: cannot create SVS-VAMANA index without specifying DISTANCE_METRIC argument` | Your `SVS-VAMANA` vector field doesn't set `DISTANCE_METRIC`, which is required. Add `DISTANCE_METRIC` with `L2`, `IP`, or `COSINE`, and count it in the number after `SVS-VAMANA`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Missing mandatory parameter: cannot create SVS-VAMANA index without specifying TYPE argument` | Your `SVS-VAMANA` vector field doesn't set `TYPE`, which is required. Add `TYPE FLOAT32` or `TYPE FLOAT16`, and count it in the number after `SVS-VAMANA`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Missing prefix: name requires '@' prefix (<argument>)` | A property in the `SORTBY` of the `COLLECT` reducer doesn't start with `@`, and the message shows it. Write each sort property with `@`, such as `SORTBY 2 @price DESC`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Missing prefix: name requires '@' prefix, JSON path require '$' prefix, got: <argument> in <clause>` | A field name in `FT.HYBRID`, in `LOAD`, `SORTBY`, or `GROUPBY`, or in the `FIELDS` of the `COLLECT` reducer, must start with `@`, or with `$` for a path. The message shows the name and where you used it. Add the prefix, as in `LOAD 1 @title`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Missing required argument K` | The `KNN` arguments of the `VSIM` clause in `FT.HYBRID` don't include `K`, the number of neighbors to return. Add it, such as `KNN 2 K 10`, or leave out `KNN` to use the default of 10. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Missing required argument RADIUS` | The `RANGE` arguments of the `VSIM` clause in `FT.HYBRID` don't include `RADIUS`, the maximum distance to match. Add it, such as `RANGE 2 RADIUS 0.5`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Missing subqueries count for FT.HYBRID` | `FT.HYBRID` ends right after the index name. Redis rejects such a short command with a wrong number of arguments error first, so you shouldn't see this message. Use `FT.HYBRID index SEARCH query VSIM @field $param`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Multiple SORTBY steps are not allowed` | `FT.SEARCH` has more than one `SORTBY`, but it can sort by only one field. Keep a single `SORTBY`, or use `FT.AGGREGATE`, which can sort by several properties in one `SORTBY` step. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Multiple SORTBY steps are not allowed. Sort multiple fields in a single step` | `FT.AGGREGATE` has two `SORTBY` steps without a `GROUPBY` between them. Combine them into one `SORTBY` that lists all the properties in order, such as `SORTBY 4 @price DESC @title ASC`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Need an argument for <argument>` | You only get this in a cluster. The `FT.SEARCH` argument named in the message, such as `LIMIT`, `SORTBY`, `RETURN`, or `DIALECT`, is missing its value, or the count after `RETURN` isn't a number. Add the value, such as `LIMIT 0 10`. | `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Need an argument for BM25STD_TANH_FACTOR` | `BM25STD_TANH_FACTOR` is the last argument, with no value after it. Give it a whole number from 1 to 10000, or remove the option to use the default. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Need an argument for DIALECT` | `DIALECT` is the last argument, with no version after it. Give a dialect from 1 to 4, such as `DIALECT 2`, or remove `DIALECT` to use the default. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_PARSE_ARGS Need an argument for TIMEOUT` | In a cluster, `TIMEOUT` is the last argument of the query, with no value after it. Give the timeout in milliseconds, such as `TIMEOUT 1000`, or remove `TIMEOUT` to use the `search-timeout` setting. | `FT.AGGREGATE`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Need argument for TIMEOUT` | `TIMEOUT` is the last argument of the query, with no value after it. Give the timeout in milliseconds, such as `TIMEOUT 1000`, or remove `TIMEOUT` to use the `search-timeout` setting. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS No index name and/or command type provided` | `FT.PROFILE` has no index name, or no `SEARCH` or `AGGREGATE`, after it. Write `FT.PROFILE`, the index name, `SEARCH` or `AGGREGATE`, and then `QUERY` and the query. | `FT.AGGREGATE`, `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS No query string provided` | The command has an index name but no query after it. Add the query string, or `*` to match all documents. You rarely see this message, because Redis usually rejects the command first with a wrong number of arguments error. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS No query string provided for SEARCH` | The `SEARCH` clause of `FT.HYBRID` has no query after it. Redis rejects a command that short with a wrong number of arguments error first, so you shouldn't see this message. Put the query right after `SEARCH`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS No schema found` | `FT.CREATE` reached the end of its arguments without finding `SCHEMA`. Add `SCHEMA` and at least one field after the index options. | `FT.CREATE` |
| `SEARCH_PARSE_ARGS NOSORT is not allowed with SORTBY` | `FT.HYBRID` has both `SORTBY` and `NOSORT`, which contradict each other. Remove `NOSORT` to sort the results by a field, or remove `SORTBY` to skip sorting. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Not enough arguments for format` | The format string of `format()` has more `%s` placeholders than values after it. Add a value for each `%s`, or write `%%` for a literal percent sign. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Not enough arguments for LOAD` | The count after `LOAD` in `FT.HYBRID` is larger than the number of arguments left in the command. Make the count match the fields that follow, such as `LOAD 2 @title @price`, or use `LOAD *`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARSE_ARGS Not enough arguments were provided based on argument count for FIELDS` | The count after `FIELDS` in the `COLLECT` reducer is larger than the number of arguments that follow it. Make the count match the fields, and check that the argument count right after `COLLECT` includes all of them. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Not supported data type is given. Expected: FLOAT16, FLOAT32` | `SVS-VAMANA` vector fields support only `FLOAT32` and `FLOAT16` vectors. Change `TYPE`, or use `HNSW` or `FLAT` for other types, such as `FLOAT64` or `INT8`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Numeric/Geo filter value/s cannot be empty` | A `FILTER` or `GEOFILTER` argument of `FT.SEARCH` has an empty value, such as `""` for the minimum or maximum. With `DIALECT 2` or higher, every value must be given; use `-inf` or `+inf` for an open-ended numeric range. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Percentage must be between 0.0 and 1.0` | The quantile that you asked the `QUANTILE` reducer for isn't between 0 and 1. Write it as a fraction, such as `0.5` for the median or `0.95` for the 95th percentile, not as `50` or `95`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS PHONETIC requires an argument` | `PHONETIC` is the last argument of a `TEXT` field, with no matcher after it. Add a matcher, such as `PHONETIC dm:en`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS REDUCE is irrelevant when compression is not of type LeanVec` | You set `REDUCE` on an `SVS-VAMANA` field whose `COMPRESSION` isn't a LeanVec type, and only `LeanVec4x8` and `LeanVec8x8` use it. Remove `REDUCE`, or use one of those compression types. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS RERANK requires an argument` | In Redis Flex, `RERANK` is the last attribute of an `HNSW` field, with no value after it. Add `TRUE` or `FALSE` after `RERANK`, and check the count after `HNSW`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS RETURN is not supported on FT.AGGREGATE` | `RETURN` only works in `FT.SEARCH`. In `FT.AGGREGATE`, use `LOAD` to choose the fields that you get back. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS RETURN path AS name - must be accompanied with NAME` | In `RETURN`, an `AS` has no name after it, often because the count after `RETURN` is too small. The count includes every field, every `AS`, and every new name, so `RETURN 3 $.title AS title` has a count of 3. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Sample size too large` | The sample size of the `RANDOM_SAMPLE` reducer is over the maximum of 1000. Ask for 1000 values or fewer for each group. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS SEPARATOR requires an argument` | `SEPARATOR` is the last argument of a `TAG` field, with no character after it. Add the separator, such as `SEPARATOR ;`, or remove `SEPARATOR` to use the default. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS SORTBY MAX is not supported by FT.SEARCH` | `FT.SEARCH` doesn't support `MAX` after `SORTBY`. Use `LIMIT` to choose how many sorted results you get, or use `FT.AGGREGATE`, where `SORTBY` accepts `MAX`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS SORTBY requires at least one sort field` | The `SORTBY` of the `COLLECT` reducer doesn't list any property. Give at least one property that starts with `@`, such as `SORTBY 1 @price`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS SUMMARIZE is not supported on FT.AGGREGATE` | `SUMMARIZE` only works in `FT.SEARCH`. Run the query with `FT.SEARCH` to get summarized fields, or remove `SUMMARIZE` from `FT.AGGREGATE`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Syntax error: RERANK value must be TRUE or FALSE` | In Redis Flex, `RERANK` on an `HNSW` field takes only `TRUE` or `FALSE`, and you gave something else. Use `RERANK TRUE` or `RERANK FALSE`; case doesn't matter. | `FT.ALTER`, `FT.CREATE` |
| `` SEARCH_PARSE_ARGS Tag separator must be a single character. Got `%s`<separator> `` | The `SEPARATOR` of a `TAG` field must be exactly one character, and the end of the message shows what you gave. Use a single character, such as `SEPARATOR ;`. The `%s` in the message isn't part of your input. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS The QUERY keyword is expected` | In a cluster, `FT.PROFILE` has no `QUERY` keyword before the query. Write `SEARCH` or `AGGREGATE`, then the optional `LIMITED`, then `QUERY` and the query, such as `FT.PROFILE idx SEARCH QUERY "hello"`. | `FT.AGGREGATE`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS TIMEOUT requires a non negative integer` | The value after `TIMEOUT` isn't a whole number of 0 or more. Give the timeout in milliseconds, such as `TIMEOUT 1000`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS TIMEOUT requires a non negative integer.` | In a cluster, the value after `TIMEOUT` isn't a whole number of 0 or more. Give the timeout in milliseconds, such as `TIMEOUT 1000`. | `FT.AGGREGATE`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS to_number: cannot convert string '<value>'` | `to_number()` got a string that isn't a number, shown in the message. Pass only numeric text, such as `"42"` or `"3.14"`, for example by filtering out other values first. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS TRAINING_THRESHOLD is irrelevant when compression was not requested` | You set `TRAINING_THRESHOLD` on an `SVS-VAMANA` field without `COMPRESSION`, and it applies only to compressed indexes. Remove it, or add a compression type, such as `COMPRESSION LVQ8`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PARSE_ARGS Unknown distance unit <unit>` | The unit at the end of `GEOFILTER`, shown in the message, isn't one that Redis Search knows. Use `m`, `km`, `mi`, or `ft`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PARSE_ARGS Unknown format specifier passed` | `format()` supports only `%s` to insert a value and `%%` for a literal percent sign. Replace other specifiers, such as `%d`, with `%s`. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_PARSE_ARGS Unrecognized argument: <argument>` | `FT.SUGGET` got an option that it doesn't know, shown in the message. After the key and the prefix, it accepts only `FUZZY`, `MAX`, `WITHSCORES`, and `WITHPAYLOADS`. Check the spelling, and quote a prefix that contains spaces so that it stays a single argument. | `FT.SUGGET` |
| `SEARCH_PARSE_ARGS Upgrade index definition was given more then once on the same index` | The module arguments have `UPGRADE_INDEX` more than once for the same index. Keep one `UPGRADE_INDEX` for each index. This message appears in the Redis log, and the module doesn't load. | `FT.CONFIG SET` |
| `SEARCH_PARSE_ARGS Value is outside acceptable bounds` | The value that you gave to `FT.CONFIG SET` is outside the range of that parameter, such as 0 where at least 1 is needed, as with `CURSOR_MAX_IDLE` or `MINPREFIX`, or a percentage over 255. Check the valid range of the parameter, and give a value inside it. | `FT.CONFIG SET` |
| `SEARCH_PARSE_ARGS YIELD_SCORE_AS specified more than once` | `COMBINE` in `FT.HYBRID` names the combined score twice: once with `YIELD_SCORE_AS` inside the counted arguments, and once after them. Keep only one `YIELD_SCORE_AS`. | `FT.HYBRID`, `FT.PROFILE` |


### SEARCH_ARG_UNRECOGNIZED

The command has an argument that Redis Search doesn't recognize. Most messages show the argument, and some also give its position. To fix it, check the spelling and the order of the arguments against the syntax on the command's page.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_ARG_UNRECOGNIZED Unknown argument` | The command has an extra argument that it doesn't accept. `FT.DROPINDEX` accepts only `DD`, the deprecated `FT.DROP` accepts only `KEEPDOCS`, and `FT._LIST` accepts only `WITHCLUSTERSTATE`. Remove or correct the last argument. | `FT.DROP`, `FT.DROPINDEX` |
| `` SEARCH_ARG_UNRECOGNIZED Unknown argument `<argument>` `` | `FT.CREATE` found an unknown argument, shown in the message, before `SCHEMA`. Check its spelling and the count of the option before it, such as `PREFIX 2`, because an extra value is read as a new argument. In a cluster, `FT.CURSOR READ` also returns this when the word after the cursor ID isn't `COUNT`. | `FT.CREATE`, `FT.CURSOR READ` |
| `` SEARCH_ARG_UNRECOGNIZED Unknown argument `<argument>` at position <position> for <main> `` | `FT.SEARCH` or `FT.AGGREGATE` found an argument that it doesn't recognize, shown in the message. The position counts from 0 at the query, so position 1 often means a query with spaces that isn't quoted. Otherwise, check the spelling, and check the count of the option before it, such as `RETURN 2`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `` SEARCH_ARG_UNRECOGNIZED Unknown argument `<argument>` at position <position> for <reducer> `` | The reducer named at the end of the message, such as `QUANTILE`, got more arguments than it uses. The message shows the first extra one, counting that reducer's arguments from 0. Lower the argument count after the reducer name, or remove the extra argument, as in `REDUCE QUANTILE 2 @price 0.5`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `` SEARCH_ARG_UNRECOGNIZED Unknown argument `<argument>` in KNN `` | The `KNN` arguments of the `VSIM` clause in `FT.HYBRID` include a name it doesn't know, shown in the message. Inside its count, `KNN` accepts only `K`, `EF_RUNTIME`, and `SHARD_K_RATIO`, so `YIELD_SCORE_AS` must come after the counted arguments. | `FT.HYBRID`, `FT.PROFILE` |
| `` SEARCH_ARG_UNRECOGNIZED Unknown argument `<argument>` in RANGE `` | The `RANGE` arguments of the `VSIM` clause in `FT.HYBRID` include a name it doesn't know, shown in the message. Inside its count, `RANGE` accepts only `RADIUS` and `EPSILON`, so `YIELD_SCORE_AS` must come after the counted arguments. | `FT.HYBRID`, `FT.PROFILE` |
| `` SEARCH_ARG_UNRECOGNIZED Unknown argument `<argument>` in SEARCH `` | The `SEARCH` clause of `FT.HYBRID` has an argument after the query that it doesn't know, shown in the message. After the query, it accepts only `SCORER` and `YIELD_SCORE_AS`, then `VSIM`. Put a query that contains spaces in quotes. | `FT.HYBRID`, `FT.PROFILE` |


### SEARCH_ADD_ARGS

Redis Search couldn't parse some arguments of `FT.CREATE`, of the older `FT.ADD` command, or of `PARAMS` in a query. In `FT.CREATE`, these are the options for the documents of the index, such as `ON`, `SCORE`, `LANGUAGE`, and `INDEXALL`. In `PARAMS`, the parameters must come in name and value pairs. To fix it, correct the argument that the message describes.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_ADD_ARGS Could not parse document score` | The score of the deprecated `FT.ADD` command, the argument right after the key, isn't a number. Give a number from 0 to 1, such as `1.0`, or write the document with `HSET` instead. | `FT.ADD`, `FT.SAFEADD` |
| `` SEARCH_ADD_ARGS Duplicate parameter `<parameter>` `` | `PARAMS` defines the parameter in the message more than once. Give each parameter a single value, and remove the repeated name and value from `PARAMS`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_ADD_ARGS Error parsing document indexing arguments` | This is the default message of `SEARCH_ADD_ARGS`: Redis Search couldn't parse the options of the deprecated `FT.ADD` command. In Redis 8.10 `FT.ADD` always returns a more specific message, so check the arguments after the score against its syntax. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_ADD_ARGS Fields must be specified in FIELD VALUE pairs` | After `FIELDS`, the deprecated `FT.ADD` command expects field names and values in pairs, but it got an odd number of arguments. Check for a missing value or an extra argument at the end. | `FT.ADD`, `FT.SAFEADD` |
| `` SEARCH_ADD_ARGS Invalid argument for `INDEXALL`, use ENABLE/DISABLE `` | The value after `INDEXALL` in `FT.CREATE` isn't valid. Use `INDEXALL ENABLE` or `INDEXALL DISABLE`; case doesn't matter. | `FT.CREATE` |
| `SEARCH_ADD_ARGS Invalid expression` | The `FILTER` expression of `FT.CREATE` couldn't be parsed. Redis 8.10 sends a more specific `SEARCH_EXPR` error instead of this text, such as a syntax error with its offset. Check the expression's syntax, and that field names start with `@`. | `FT.CREATE` |
| `SEARCH_ADD_ARGS Invalid language` | The `LANGUAGE` value of `FT.CREATE` isn't a language that Redis Search supports. Use the full English name of a supported language, such as `english`, `german`, or `chinese`; case doesn't matter. The `FT.CREATE` page lists them. | `FT.CREATE` |
| `SEARCH_ADD_ARGS Invalid rule type: <type>` | The value after `ON` in `FT.CREATE`, shown in the message, isn't a type of key that Redis Search can index. Use `ON HASH` or `ON JSON`. `ON JSON` works only when the module that provides `JSON.SET` is loaded. | `FT.CREATE` |
| `SEARCH_ADD_ARGS Invalid score` | The `SCORE` value of `FT.CREATE` isn't a number from 0 to 1. It sets the default score of documents that don't have their own, so use a value such as `SCORE 1` or `SCORE 0.5`. | `FT.CREATE` |
| `SEARCH_ADD_ARGS Multiple PARAMS are not allowed. Parameters can be defined only once` | The command has more than one `PARAMS` argument. Put all parameters in a single `PARAMS`, followed by the count of the names and values, such as `PARAMS 4 min 10 max 20`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_ADD_ARGS No field list found` | The deprecated `FT.ADD` command has no `FIELDS` keyword, so it has no fields to store. Add `FIELDS` followed by field and value pairs after the options. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_ADD_ARGS Parameters must be specified in PARAM VALUE pairs` | The count after `PARAMS` is 0 or odd, but parameters come in name and value pairs. Set the count to the number of names plus values that follow, such as `PARAMS 2 radius 10`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_ADD_ARGS Parsing error for document option <option>: <reason>` | An option of the deprecated `FT.ADD` command, such as `LANGUAGE`, `PAYLOAD`, or `IF`, has no value after it. The message names the option. Add its value, or remove the option. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_ADD_ARGS Score must be between 0 and 1` | The score of the deprecated `FT.ADD` command, the argument right after the key, is less than 0 or greater than 1. Give a score from 0 to 1, such as `1.0`. | `FT.ADD`, `FT.SAFEADD` |
| `` SEARCH_ADD_ARGS Unknown keyword `<argument>` provided `` | The deprecated `FT.ADD` command got an option it doesn't know, shown in the message. The options are `REPLACE`, `PARTIAL`, `NOCREATE`, `PAYLOAD`, `LANGUAGE`, and `IF`, and they must come before `FIELDS`, so check the spelling and the order. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_ADD_ARGS Unsupported language` | The `LANGUAGE` option of the deprecated `FT.ADD` command names a language that Redis Search doesn't support for stemming. Use one of the languages that `FT.CREATE` accepts for `LANGUAGE`, such as `english`, `french`, or `chinese`. | `FT.ADD`, `FT.SAFEADD` |


### SEARCH_OPTION_INVALID

Redis Search doesn't recognize the name of an option or an attribute. `Invalid attribute` refers to a query attribute, such as `$weight` in `(foo bar) => { $weight: 2.0; }`. `Invalid option` refers to a parameter of `FT.CONFIG SET`, or to a parameter of a vector query. To fix it, check the name for typos. For the attributes that you can use, see [Query attributes](https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/query_attributes).

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_OPTION_INVALID Invalid attribute <attribute>` | The query sets an attribute, shown in the message, that Redis Search doesn't accept there. Query terms accept `$weight`, `$slop`, `$inorder`, and `$phonetic`, and vector queries also accept `$yield_distance_as` and vector parameters such as `$EF_RUNTIME`. Check the spelling. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_OPTION_INVALID Invalid option` | `FT.CONFIG SET` doesn't know the parameter name that you gave. Check the spelling, and run `FT.CONFIG GET *` to list the parameters that exist. | `FT.CONFIG SET` |
| `SEARCH_OPTION_INVALID Invalid option (Error parsing vector similarity parameters)` | Your vector query has an option that the field's algorithm doesn't accept, such as a misspelled name. Check the options inside `=>[KNN ...]` or `VECTOR_RANGE`, such as `EF_RUNTIME`, `EPSILON`, `HYBRID_POLICY`, and `BATCH_SIZE` for `HNSW` fields. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_OPTION_BAD

The option that you used isn't available in the current mode. With `FT.CONFIG SET`, the message `Not modifiable at runtime` means that you can set the parameter only when Redis starts. To fix it, set the parameter in the Redis configuration file, and then restart Redis.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_OPTION_BAD Cannot set dynamic field to sortable - %s<field>` | Redis Search refused to make a dynamic field `SORTABLE`. Fields that you define with `FT.CREATE` or `FT.ALTER` are never dynamic in Redis Search 8.10, so you shouldn't see this message. The `%s` in it isn't part of your input. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_OPTION_BAD Not modifiable at runtime` | The parameter that you passed to `FT.CONFIG SET` can only be set when Redis starts, as with `MAXDOCTABLESIZE`, `GC_POLICY`, or `MT_MODE`. Set it in the Redis configuration file, and then restart Redis. | `FT.CONFIG SET` |
| `SEARCH_OPTION_BAD Option not supported for current mode` | This is the default text of `SEARCH_OPTION_BAD`. Redis 8.10 sends a specific message instead, such as `Not modifiable at runtime` when `FT.CONFIG SET` targets a parameter that you can set only when Redis starts. | Redis Search commands |


### SEARCH_ATTR_BAD

An argument names a field, or gives a value, that this operation doesn't accept. For example, `FT.TAGVALS` needs the name of a `TAG` field in the index, and the `COUNT` reducer doesn't take arguments. To fix it, check the name and type of the field with [`FT.INFO`](https://redis.io/docs/latest/commands/ft.info), or remove the extra arguments.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_ATTR_BAD Attribute not supported for term` | This is the default text of `SEARCH_ATTR_BAD`, which means that an argument names a field or gives a value that the operation doesn't accept. Redis 8.10 sends a specific message instead, such as `No such field` or `Not a tag field` from `FT.TAGVALS`. | Redis Search commands |
| `SEARCH_ATTR_BAD Count accepts 0 values only` | The `COUNT` reducer doesn't take arguments, but its argument count isn't 0. Write `REDUCE COUNT 0`, optionally followed by `AS` and a name. To count the distinct values of a property, use `COUNT_DISTINCT` instead. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_ATTR_BAD No such field` | `FT.TAGVALS` can't find the field you named in the index. Field names are case-sensitive, so check the name against `FT.INFO`. For a JSON index, use the field's `AS` name, not its JSONPath. | `FT.TAGVALS` |
| `SEARCH_ATTR_BAD Not a tag field` | `FT.TAGVALS` only works on `TAG` fields, and the field you named has another type. Check the field types with `FT.INFO`. | `FT.TAGVALS` |


### SEARCH_VALUE_BAD

A value in your command, in a configuration parameter, or in a document isn't valid. The description after the code says which value. Examples are an unknown policy for `ON_TIMEOUT` in `FT.CONFIG SET`, a geoshape that Redis Search can't parse, or a JSON array with a value that isn't a string in a `TAG` field. To fix it, correct the value that the description names.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_VALUE_BAD Default dialect version cannot be higher than 4` | `DEFAULT_DIALECT` can only be from 1 to 4. Set it to a value in that range. | `FT.CONFIG SET` |
| `SEARCH_VALUE_BAD Empty array for vector field on JSON document` | A `VECTOR` field in a JSON document holds an empty array, so Redis Search has no vector to index. Store an array with exactly `DIM` numbers, or leave the field out of the document. | Indexing, shown in FT.INFO |
| `SEARCH_VALUE_BAD Error indexing geoshape: <error>` | Redis Search couldn't parse a `GEOSHAPE` value as a shape, so it didn't index the document. The text after the colon comes from the shape parser. Store well-known text (WKT), such as `POINT (2 1)` or `POLYGON ((0 0, 0 1, 1 1, 0 0))`. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_VALUE_BAD Error querying geoshape index: <error>` | Redis Search couldn't read the shape in your `GEOSHAPE` query, usually because its well-known text (WKT) is malformed, such as a `POLYGON` with a coordinate that isn't a number or a missing parenthesis. The text after the colon gives the reason. Fix the shape, which you usually pass in `PARAMS`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_VALUE_BAD EXPAND format is only supported with JSON` | `FORMAT EXPAND` only works on an index of JSON documents, and this index is on hashes. Remove `FORMAT EXPAND`, or use `FORMAT STRING`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_VALUE_BAD EXPAND format is only supported with RESP3` | `FORMAT EXPAND` returns JSON values as structured data, which needs version 3 of the Redis serialization protocol (RESP3). Switch the connection to RESP3, for example with `HELLO 3`, or remove `FORMAT EXPAND`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_VALUE_BAD Inconsistent index state` | You only get this error in a cluster. For `FT.INFO`, the shards reported different numbers of fields for the index, so the index definition isn't the same on every shard. Run `FT.INFO` again, and if the error continues, check the index on each shard. | `FT.INFO` |
| `SEARCH_VALUE_BAD Invalid default scorer value` | `DEFAULT_SCORER` must name a scorer that Redis Search knows, and scorer names are case-sensitive. Use one of `TFIDF`, `TFIDF.DOCNORM`, `BM25`, `BM25STD` (the default), `BM25STD.TANH`, `BM25STD.NORM`, `DISMAX`, `DOCSCORE`, or `HAMMING`. | `FT.CONFIG SET` |
| `SEARCH_VALUE_BAD Invalid ON_OOM value` | `ON_OOM` accepts only `return`, `fail`, or `ignore`. Set it to one of these values. | `FT.CONFIG SET` |
| `SEARCH_VALUE_BAD Invalid ON_TIMEOUT value` | `ON_TIMEOUT` accepts only `return`, `fail`, or `return-strict`. Note the hyphen in `return-strict`: `RETURN_STRICT` with an underscore isn't accepted. | `FT.CONFIG SET` |
| `SEARCH_VALUE_BAD Invalid value was given` | An option of your vector query has a value that isn't valid, such as `EF_RUNTIME 0` or a word where a number belongs. Fix the value inside `=>[KNN ...]` or `VECTOR_RANGE`. Redis 8.10 sends this text with `(Error parsing vector similarity parameters)` added. | Search queries |
| `SEARCH_VALUE_BAD Invalid value was given (Error parsing vector similarity parameters)` | An option of your vector query has a value that isn't valid, such as `EF_RUNTIME 0` or a word where a number belongs. Fix the value inside `=>[KNN ...]` or `VECTOR_RANGE`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_VALUE_BAD Invalid YIELD_SCORE_AS value` | `FT.HYBRID` couldn't read the name after `YIELD_SCORE_AS`. In Redis 8.10 a missing name returns `Missing argument value for YIELD_SCORE_AS` instead, so you shouldn't see this message. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_VALUE_BAD Need an argument for FORMAT` | `FORMAT` is the last argument, with no value after it. Give it `STRING` or `EXPAND`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_VALUE_BAD NUMERIC fields can only contain numeric or nulls` | A `NUMERIC` field in a JSON document holds an array, or a JSONPath with several matches, that includes a value other than a number or `null`, such as a string. Store only numbers in it. | Indexing, shown in FT.INFO |
| `SEARCH_VALUE_BAD TEXT/TAG fields can only contain strings or nulls` | A `TEXT`, `TAG`, or `GEO` field in a JSON document holds an array, or a JSONPath with several matches, that includes a value other than a string or `null`, such as a number. Store those values as strings. | Indexing, shown in FT.INFO |


### SEARCH_NUMERIC_VALUE_INVALID

Redis Search expected a number, but the value isn't one. You get this error for a query parameter that the query uses as a number, such as the number of neighbors in a K nearest neighbors (KNN) vector query. You also get it for an arithmetic operation in `APPLY`, and for the value of a `NUMERIC` field in a hash. To fix it, check the value that the message shows.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_NUMERIC_VALUE_INVALID Invalid numeric value` | An arithmetic operator in `APPLY` or `FILTER`, such as `+` or `*`, got a value that isn't a number, for example a `TEXT` field. Use arithmetic only on numeric values. In `FT.INFO`, the same message as the last indexing error means that a `NUMERIC` field of a document holds something that isn't a number. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `` SEARCH_NUMERIC_VALUE_INVALID Invalid numeric value (<value>) for parameter `<parameter>` `` | A `PARAMS` value that your query uses as a number isn't one. The parameter in the message stands for a `KNN` count, which must be a whole number of 0 or more, or for a geo longitude, latitude, or radius. Pass a valid number. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_NUMERIC_VALUE_INVALID Invalid numeric value: '<value>'` | Redis Search didn't index a hash because a field that the index defines as `NUMERIC` holds the value in the message, which isn't a number. Store a plain number, such as `42` or `-3.5`, or define the field as `TEXT` or `TAG` instead. | `FT.ADD`, `FT.SAFEADD` |


### SEARCH_PARAM_DUP

A vector query, or a clause of `FT.HYBRID`, gives the same parameter twice, such as `K` or `EF_RUNTIME`. To fix it, give each parameter only once. When a name appears twice in `PARAMS`, you get [`SEARCH_ADD_ARGS`](#search_add_args) instead.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_PARAM_DUP Duplicate EF_RUNTIME argument` | The `KNN` arguments of the `VSIM` clause in `FT.HYBRID` set `EF_RUNTIME` more than once. Give it only once, and correct the count after `KNN`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARAM_DUP Duplicate EPSILON argument` | The `RANGE` arguments of the `VSIM` clause in `FT.HYBRID` set `EPSILON` more than once. Give it only once, and correct the count after `RANGE`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARAM_DUP Duplicate K argument` | The `KNN` arguments of the `VSIM` clause in `FT.HYBRID` set `K` more than once. Give it only once, and correct the count after `KNN`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARAM_DUP Duplicate RADIUS argument` | The `RANGE` arguments of the `VSIM` clause in `FT.HYBRID` set `RADIUS` more than once. Give it only once, and correct the count after `RANGE`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARAM_DUP Duplicate SHARD_K_RATIO argument` | The `KNN` arguments of the `VSIM` clause in `FT.HYBRID` set `SHARD_K_RATIO` more than once. Give it only once, and correct the count after `KNN`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARAM_DUP Duplicate YIELD_SCORE_AS argument` | The `VSIM` clause of `FT.HYBRID` has `YIELD_SCORE_AS` more than once. Give the vector score only one name. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_PARAM_DUP Parameter was specified twice` | You gave the same parameter twice, such as `EF_RUNTIME` twice inside `=>[KNN ...]`, or `K` twice in `FT.HYBRID`. Remove the duplicate. Redis 8.10 always adds more detail to this text. | Search queries |
| `SEARCH_PARAM_DUP Parameter was specified twice (Error parsing vector similarity parameters)` | Your vector query sets the same option twice, such as `EF_RUNTIME` appearing two times inside `=>[KNN ...]`. Remove the duplicate. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_FIELD_DUP

Two fields or properties in your command have the same name. For example, two `REDUCE` steps in a `GROUPBY` use the same `AS` name, or a vector query sets its distance field twice. To fix it, give each one a different name.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_FIELD_DUP Could not create score alias, name already exists in query, score alias: <alias>` | The `YIELD_SCORE_AS` name of `COMBINE` in `FT.HYBRID` is already used in the query, for example by the `YIELD_SCORE_AS` of the `SEARCH` or `VSIM` clause, or by a field in `LOAD`. Choose a name that nothing else in the query uses. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_FIELD_DUP Could not create score alias, name already exists in query<alias>` | The `YIELD_SCORE_AS` name of the `SEARCH` clause in `FT.HYBRID` is already used in that subquery, so Redis Search can't add the score under that name. The name follows the message text without a space. Choose a different name. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_FIELD_DUP Distance field was specified twice for vector query: <alias> and <alias>` | A vector query names its distance field twice, with `AS` inside the brackets and with `$yield_distance_as` after them, as in `*=>[KNN 10 @v $vec AS d]=>{$yield_distance_as: e}`. Keep only one of them. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_FIELD_DUP Field was specified twice` | This is the default text of `SEARCH_FIELD_DUP`, which means that the same field or alias appears twice where it must be unique. Redis 8.10 sends a specific message instead, for example one saying that a property is specified more than once. Remove or rename the duplicate. | Redis Search commands |
| `` SEARCH_FIELD_DUP Property `<property>` specified more than once `` | Two properties in the command have the same name, shown in the message. This happens when `GROUPBY` lists a property twice, a `REDUCE ... AS` name repeats or matches a `GROUPBY` property, or two vector distance fields share a name. Use different names. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_FIELD_DUP Tried to insert field twice: '<field>'` | A document has two values for the same field of the index, named in the message, so Redis Search didn't index the document. Make sure that each field appears only once in the document. You can get this from `FT.ADD`, or see it in `FT.INFO` as the last indexing error. | `FT.ADD`, `FT.SAFEADD` |


### SEARCH_QUERY_BAD

Redis Search found a problem when it checked your query against the index, or when it checked a new index definition. The description after the code says what's wrong. For example, the query names a language or a scorer that doesn't exist, or the query vector has a different size than the vector field expects. Messages that mention a disk index only come from an index that uses Redis Flex. To fix it, correct the part of the command that the description names.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_QUERY_BAD BUG: invalid index type` | Redis Search found a field type it doesn't know while it indexed a document. This is an internal consistency check that shouldn't fail, so it points to a bug in Redis Search rather than to your data. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_QUERY_BAD Cannot use HIGHLIGHT/SUMMARIZE because NOOFSETS was specified at index level` | The index was created with `NOOFFSETS` or `NOHL`, so it doesn't store the offsets that `HIGHLIGHT` and `SUMMARIZE` need. Remove `HIGHLIGHT` and `SUMMARIZE` from the query, or drop the index and create it again without `NOOFFSETS` and `NOHL`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD Could not validate the query nodes (bad attribute?)` | This is the default text of `SEARCH_QUERY_BAD`, which covers queries and schemas that parse but aren't valid, such as a duplicate field name or a query vector of the wrong size. Redis 8.10 sends a specific message instead of this text. | Redis Search commands |
| `SEARCH_QUERY_BAD Disk HNSW index requires EF_CONSTRUCTION parameter` | In Redis Flex, an `HNSW` vector field must set `EF_CONSTRUCTION`, as well as `M`, `EF_RUNTIME`, and `RERANK`. Add it, for example `EF_CONSTRUCTION 200`, and count it in the number after `HNSW`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk HNSW index requires EF_RUNTIME parameter` | In Redis Flex, an `HNSW` vector field must set `EF_RUNTIME`, as well as `M`, `EF_CONSTRUCTION`, and `RERANK`. Add it, for example `EF_RUNTIME 10`, and count it in the number after `HNSW`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk HNSW index requires M parameter` | In Redis Flex, an `HNSW` vector field must set `M`, as well as `EF_CONSTRUCTION`, `EF_RUNTIME`, and `RERANK`. Add it, for example `M 16`, and count it in the number after `HNSW`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk HNSW index requires RERANK parameter` | In Redis Flex, an `HNSW` vector field must set `RERANK`, as well as `M`, `EF_CONSTRUCTION`, and `EF_RUNTIME`. Add `RERANK TRUE` or `RERANK FALSE`, and count it in the number after `HNSW`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk index does not support <vector_type> vector type` | In Redis Flex, `HNSW` vector fields support only `FLOAT32` and `FLOAT16`, and you used the type named in the message. Change `TYPE` to `FLOAT32` or `FLOAT16`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk index does not support FLAT algorithm` | Redis Flex indexes don't support the `FLAT` vector algorithm. Use `HNSW`, and set `M`, `EF_CONSTRUCTION`, `EF_RUNTIME`, and `RERANK`, which Flex requires. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk index does not support INDEXMISSING fields` | Redis Flex indexes don't support `INDEXMISSING`, so you can't search them for missing fields with `ismissing()`. Remove `INDEXMISSING` from the field. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk index does not support multi-value vectors` | In Redis Flex, a vector field can't hold several vectors per document, as a path such as `$.vectors[*]` would. Redis Search 8.10 rejects such paths earlier, with `Disk JSON index supports only single-value JSONPath fields`, so you're unlikely to see this message. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk index does not support NOINDEX fields` | Redis Flex indexes don't support `NOINDEX` fields. Remove `NOINDEX` so that the field is indexed, or remove the field from the schema. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk index does not support non-TEXT/VECTOR/TAG/NUMERIC fields` | Redis Flex indexes support only `TEXT`, `TAG`, `NUMERIC`, and `VECTOR` fields. In Redis Search 8.10, `GEO` and `GEOSHAPE` fields fail earlier with their own message, so you're unlikely to see this one. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk index does not support SORTABLE fields` | Redis Flex indexes don't support `SORTABLE` fields. Remove `SORTABLE`. In Redis Flex, `SORTBY` can sort only vector query results by their vector distance. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk index does not support SVS algorithm` | Redis Flex indexes don't support the `SVS-VAMANA` vector algorithm. Use `HNSW`, and set `M`, `EF_CONSTRUCTION`, `EF_RUNTIME`, and `RERANK`, which Flex requires. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Disk JSON index does not support multi-value JSONPath results` | You only get this from a JSON index that uses Redis Flex. A field's JSONPath returned more than one value, which disk indexes don't support. Use a JSONPath that returns a single value. | Indexing, shown in FT.INFO |
| `SEARCH_QUERY_BAD Disk JSON index supports JSON array values only for VECTOR fields` | You only get this from a JSON index that uses Redis Flex. A field other than a `VECTOR` field holds a JSON array, which disk indexes don't support. Store a single value in that field. | Indexing, shown in FT.INFO |
| `SEARCH_QUERY_BAD Disk JSON index supports only single-value JSONPath fields` | In Redis Flex, each field of an `ON JSON` index must use a path that matches one value, and yours can match several, for example with `[*]` or `..`. Change the path so that it points to a single value. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Duplicate field in schema - <field>` | Your schema has the field name in the message twice, or `FT.ALTER` adds a field that the index already has. Give each field a unique name. To index the same attribute again, add it under another name with `AS`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Duplicate RERANK parameter` | In Redis Flex, your `HNSW` vector field sets `RERANK` more than once. Keep one `RERANK TRUE` or `RERANK FALSE`, and lower the count after `HNSW` to match. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Error parsing vector similarity query: negative radius (<radius>) given in a range query` | The radius of your `VECTOR_RANGE` query, shown in the message, is negative. The radius is a distance, so use a value of 0 or more. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD Error parsing vector similarity query: query KNN K parameter is too large, must not exceed <limit>` | The k of your `KNN` query is larger than the maximum shown in the message, which is 2 to the power of 58. Ask for far fewer results. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD Error parsing vector similarity query: query vector blob size (<size>) does not match index's expected size (<size>).` | The query vector that you passed in `PARAMS` has a different byte length than the field expects: `DIM` times the size of the field's `TYPE`, such as 4 bytes for `FLOAT32`. Encode the vector with the field's dimension and type. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD Failed to apply debug timeouts` | You only get this from the debug command `_FT.DEBUG FT.HYBRID`, which the tests of Redis Search use. Its timeout parameters couldn't be applied to the query. A normal `FT.HYBRID` call never returns this message. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_QUERY_BAD field does not support phonetics` | The query sets the `$phonetic` attribute, to `true` or `false`, on a term whose fields don't use phonetic matching. Only `TEXT` fields created with `PHONETIC`, such as `PHONETIC dm:en`, support it, so remove `$phonetic` or query a phonetic field. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD Field is not a geo field, field: <field>` | `GEOFILTER` in `FT.SEARCH` names a field that's in the index but isn't a `GEO` field. Use `GEOFILTER` only on `GEO` fields. With `DIALECT 1`, the same query returns no results instead of this error. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD Field is not a numeric field, field: <field>` | `FILTER` in `FT.SEARCH` names a field that's in the index but isn't a `NUMERIC` field. Use `FILTER` only on `NUMERIC` fields, and put conditions on other fields in the query string. With `DIALECT 1`, the same query returns no results instead of this error. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD Field name cannot be empty` | A field name, or the alias after `AS`, is an empty string in your schema. Give every field a name that isn't empty. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Field name cannot contain null bytes` | A field name or alias in your schema contains a null byte, which Redis Search doesn't allow. Remove the null byte from the name. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Field path cannot contain null bytes` | The path of a field, the part before `AS`, contains a null byte, which Redis Search doesn't allow. Remove the null byte from the field name or path. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD HIGHLIGHT/SUMMARIZE is not supported for JSON fields with multi-value JSONPath` | You used `HIGHLIGHT` or `SUMMARIZE` on a JSON field whose JSONPath can return several values, such as `$.tags[*]`. Highlight or summarize only fields whose path leads to a single value, or remove `HIGHLIGHT` and `SUMMARIZE`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD HIGHLIGHT/SUMMARIZE on JSON indexes requires RETURN with explicit field names` | On a JSON index, `HIGHLIGHT` and `SUMMARIZE` need `RETURN` with the names of the fields to return, because otherwise the whole document comes back as one JSON string. Add `RETURN` with those fields, such as `RETURN 1 title HIGHLIGHT FIELDS 1 title`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD Invalid shard k ratio value '<value>'` | The shard k ratio of your vector query, set with the `$SHARD_K_RATIO` query attribute or the `SHARD_K_RATIO` argument of `FT.HYBRID`, isn't a number. Use a number greater than 0 and at most 1, such as `0.5`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_QUERY_BAD Invalid shard k ratio value: Shard k ratio must be greater than <min> and at most <max> (got <value>)` | The shard k ratio of your vector query, set with `$SHARD_K_RATIO` or the `SHARD_K_RATIO` argument of `FT.HYBRID`, is out of range; the message shows your value. Use a number greater than 0 and at most 1. It sets the share of the `KNN` results that each shard returns. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK` |
| `SEARCH_QUERY_BAD Key does not exist or is not a hash: <key>` | Redis Search went to index the hash named in the message, but the key no longer existed or no longer held a hash. This usually means the key expired, was deleted, or changed type in the meantime. `FT.INFO` reports it as the last indexing error. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_QUERY_BAD Key does not exist or is not a json: <key>` | Redis Search went to index the JSON document named in the message, but the key no longer held a JSON value. This usually means the key was replaced by another type, or expired, in the meantime. `FT.INFO` reports it as the last indexing error. | Indexing, shown in FT.INFO |
| `SEARCH_QUERY_BAD Key does not exist: <key>` | Redis Search went to index the JSON document named in the message, but the key no longer existed. This usually means it expired or was deleted in the meantime. `FT.INFO` reports this as the last indexing error. | Indexing, shown in FT.INFO |
| `SEARCH_QUERY_BAD LOAD cannot be applied after projectors or reducers` | In `FT.AGGREGATE`, a `LOAD` step comes after a `GROUPBY`, when the original documents are no longer available. Move `LOAD` before the first `GROUPBY`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD Matcher Format: <2 chars algorithm>:<2 chars language>. Support algorithms: double metaphone (dm). Supported languages: English (en), French (fr), Portuguese (pt) and Spanish (es)` | The matcher after `PHONETIC` isn't supported. Use `dm:en`, `dm:fr`, `dm:pt`, or `dm:es`, in lowercase: the double metaphone algorithm for English, French, Portuguese, or Spanish. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD MAXTEXTFIELDS cannot be used with NOFIELDS` | You used both `MAXTEXTFIELDS` and `NOFIELDS` in `FT.CREATE`, and they conflict. `NOFIELDS` stops storing which field each word came from, which is what `MAXTEXTFIELDS` widens. Remove one of them. | `FT.CREATE` |
| `SEARCH_QUERY_BAD No such language` | The value of `LANGUAGE` in the query isn't a language that Redis Search supports for stemming. Use a supported language name, such as `english`, `french`, or `chinese`, or leave out `LANGUAGE` to use the default language of the index. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD No such scorer <scorer>` | The `SCORER` in the query isn't a scoring function that Redis Search knows, and scorer names are case-sensitive. Use one of `TFIDF`, `TFIDF.DOCNORM`, `BM25`, `BM25STD` (the default), `BM25STD.TANH`, `BM25STD.NORM`, `DISMAX`, `DOCSCORE`, or `HAMMING`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `` SEARCH_QUERY_BAD option `<option>` is mutually exclusive with simple (i.e. search) options `` | You used `GROUPBY` in `FT.SEARCH`, but grouping is only available in `FT.AGGREGATE`. Run the query with `FT.AGGREGATE` to group the results, or remove `GROUPBY`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `` SEARCH_QUERY_BAD Property `<property>` is not in schema `` | `HIGHLIGHT` or `SUMMARIZE` in `FT.SEARCH` names a field, shown in the message, that the query returns but that isn't a field of the index. Redis Search can only highlight or summarize fields of the index, so remove it from `HIGHLIGHT` or `SUMMARIZE`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD Redis Flex pre-filtered vector queries currently require explicit HYBRID_POLICY` | In Redis Flex, a `KNN` query with a filter before `=>`, such as `(@tag:{a})=>[KNN 10 @vec $v]`, must set `HYBRID_POLICY`. Add `HYBRID_POLICY BATCHES` or `HYBRID_POLICY ADHOC_BF` inside the brackets. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD RERANK is only supported for disk-based vector indexes` | You set `RERANK` on an `HNSW` vector field, but `RERANK` applies only to Redis Flex indexes, which keep vectors on disk. Remove `RERANK` and its value, and lower the count after `HNSW` by 2. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_QUERY_BAD Unknown Field '<field>'` | `FILTER` in `FT.SEARCH` names a field that isn't in the index. Check the field name for typos, and run `FT.INFO` to see the fields of the index. With `DIALECT 1`, the same query returns no results instead of this error. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_QUERY_BAD Unknown Field, field: <field>` | `GEOFILTER` in `FT.SEARCH` names a field that isn't in the index. Check the field name for typos, and run `FT.INFO` to see the fields of the index. With `DIALECT 1`, the same query returns no results instead of this error. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


## Indexes

### SEARCH_INDEX_NOT_FOUND

The index that you named doesn't exist. With `FT.ALIASADD` and `FT.ALIASUPDATE`, the name must be an index, not an alias. To fix it, check the name for typos. To see the names of all indexes, run [`FT._LIST`](https://redis.io/docs/latest/commands/ft._list).

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_INDEX_NOT_FOUND Alias does not belong to provided spec` | You passed an index name where `FT.ALIASDEL` or `FT.ALIASUPDATE` expects an alias. Pass the name of an alias that you created with `FT.ALIASADD`, not the name of the index. | `FT.ALIASDEL`, `FT.ALIASUPDATE`, `FT.CREATE`, `FT.DROP`, `FT.DROPINDEX` |
| `SEARCH_INDEX_NOT_FOUND Index not found` | Redis Search tried to index a document for an index that no longer exists, for example because it was dropped at that moment. With no index left to record it, you don't normally see this message. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_INDEX_NOT_FOUND Index not found: <index>` | No index or alias has the name in the message. Check the name for typos, and run `FT._LIST` to see the indexes that exist. If the index doesn't exist yet, create it with `FT.CREATE`. | Redis Search commands |
| `SEARCH_INDEX_NOT_FOUND Unknown index name (or name is an alias itself)` | The second argument of `FT.ALIASADD` or `FT.ALIASUPDATE` must be the name of an existing index. Often the name you gave is an alias, and an alias can't point to another alias, so give the name of the index itself. | `FT.ALIASADD`, `FT.ALIASUPDATE` |


### SEARCH_INDEX_EXISTS

An index or an alias with that name already exists. `FT.CREATE` returns `Index already exists`, and `FT.ALIASADD` returns `Alias already exists`. A query can also return this code when it gives a vector distance field the name of a field in the index. To fix it, choose a name that isn't in use yet.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_INDEX_EXISTS Alias already exists` | An alias with this name already exists, for this index or another one. Choose a different alias name, or use `FT.ALIASUPDATE` to point the existing alias to another index. | `FT.ALIASADD`, `FT.ALIASUPDATE` |
| `SEARCH_INDEX_EXISTS Index already exists` | `FT.CREATE` can't create the index, because an index with that name already exists. Choose another name, or drop the old index with `FT.DROPINDEX` first. `FT.INFO` shows the definition of the existing index. | `FT.CREATE` |
| `` SEARCH_INDEX_EXISTS Property `<property>` already exists in schema `` | A vector distance field has the name of a field of the index, shown in the message. You set that name with `AS` in a vector query, with `$yield_distance_as`, or with `YIELD_SCORE_AS` in `VSIM`. Choose a name that isn't a field of the index. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_ALIAS_CONFLICT

`FT.ALIASADD` or `FT.ALIASUPDATE` can't create the alias because an index already has that name. To fix it, choose an alias name that no index uses.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_ALIAS_CONFLICT Alias conflicts with an existing index name` | `FT.ALIASADD` or `FT.ALIASUPDATE` can't create the alias, because an index already has that name. Aliases and index names share one namespace, so choose an alias name that no index uses. | `FT.ALIASADD`, `FT.ALIASUPDATE` |


### SEARCH_INDEX_DROPPED_BG

The index was dropped after Redis Search accepted the query, but before the query ran. With `FT.CURSOR READ`, the index was dropped while the cursor was idle. To fix it, check that the index exists, create it again if you need it, and then run the query again.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_INDEX_DROPPED_BG The index was dropped before the query could be executed` | The index was dropped, for example with `FT.DROPINDEX`, after Redis Search accepted your query but before the query started to run. Check that the index exists with `FT._LIST`, create it again if you need it, and then run the query again. | `FT.AGGREGATE`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_INDEX_DROPPED_BG The index was dropped while the cursor was idle` | The index was dropped after you opened the cursor and before this `FT.CURSOR READ`, so the cursor can't continue, and Redis Search deletes it. Create the index again if you need it, and then run `FT.AGGREGATE` with `WITHCURSOR` to get a new cursor. | `FT.CURSOR READ` |


### SEARCH_PATH_BAD

A field in `FT.CREATE` or `FT.ALTER` has a JSONPath that Redis Search can't parse. The message shows the path, the field, and the index. To fix it, correct the syntax of the path, for example a missing closing bracket.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_PATH_BAD Invalid JSONPath '<path>' in attribute '<field>' in index '<index>'` | The JSONPath of a field in `FT.CREATE` or `FT.ALTER` has a syntax error. The message shows the path, the field, and the index. Correct the path, for example `$.a[0]` instead of `$.a[`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_PATH_BAD Invalid path` | This is the default text of `SEARCH_PATH_BAD`: the path of a field in an `ON JSON` index isn't valid. Redis 8.10 sends `Invalid JSONPath` with the path, the field, and the index instead. Fix the path, which starts with `$`. | Redis Search commands |


## Documents

Redis Search indexes a document when you write it with a command such as `HSET` or `JSON.SET`. If Redis Search can't index the document, that command still succeeds. Redis Search leaves the document out of the index, and `FT.INFO` shows the message as the `last indexing error`.

### SEARCH_DOC_NOT_FOUND

Redis Search couldn't find a document that the command needs. With the older `FT.ADD` command, you get `Document does not exist` when you use the `NOCREATE` option and no document has that key. To fix it, add the document without `NOCREATE`.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_DOC_NOT_FOUND` | `FT.ADD` with `REPLACE` and `IF` found the key in Redis, but the index doesn't have a document for it, so it can't check the `IF` condition. The message has no description. Check that the key matches the prefixes of the index, or add the document without `IF`. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_DOC_NOT_FOUND Document does not exist` | You called the deprecated `FT.ADD` command with `NOCREATE`, but no key with that name exists. `NOCREATE` only updates existing documents, so remove it to create the document, or check the key name. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_DOC_NOT_FOUND Document not found` | Redis Search couldn't open a document's key while reading its fields, usually because the key was deleted or expired during the operation. Queries skip such documents instead of failing, so you rarely see this. Retry the command. | Search queries |


### SEARCH_DOCUMENT_EXISTS

`FT.ADD` found an existing document with the same key, and you didn't use the `REPLACE` option. To fix it, add `REPLACE` to update the document, or use a different key.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_DOCUMENT_EXISTS Document already exists` | The deprecated `FT.ADD` command found an existing hash with that key, and you didn't give `REPLACE`. Add `REPLACE` to overwrite the document, use another key, or write the document with `HSET` instead. | `FT.ADD`, `FT.SAFEADD` |


### SEARCH_DOCUMENT_NOT_ADDED

`FT.ADD` didn't update the document because the condition of its `IF` option wasn't true. In this case, `FT.ADD` replies with [`NOADD`](#noadd) instead of this message.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_DOCUMENT_NOT_ADDED Document was not added because condition was unmet` | `FT.ADD` didn't update the document because its `IF` condition wasn't true. You don't normally see this text, because `FT.ADD` replies with `NOADD` in this case. Check the `IF` expression if you expected an update. | `FT.ADD`, `FT.SAFEADD` |


### NOADD

`FT.ADD` didn't add or update the document because the condition of its `IF` option wasn't true for the existing document. A condition that uses a field that the document doesn't have also counts as not true. This reply means that the command didn't change anything, not that it failed. If you expected the document to change, check the `IF` condition.

| Error message | Explanation | Returned by |
|---|---|---|
| `NOADD` | The deprecated `FT.ADD` command didn't change the document, because its `IF` condition was false for the existing document, or used an index field that the document doesn't have. This isn't a failure. Check the `IF` expression if you expected an update. | `FT.ADD`, `FT.SAFEADD` |


### SEARCH_REDIS_KEY_TYPE_BAD

The key exists but doesn't hold a hash, so Redis Search can't use it as a document. You get this error from `FT.ADD` when the key holds another type of value, such as a string. To fix it, use a different key, or delete the existing key first.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_REDIS_KEY_TYPE_BAD Invalid Redis key` | The key exists but doesn't hold a hash, so Redis Search can't use it as a document. With the deprecated `FT.ADD` command, this means the key holds another type, such as a string, so delete the key first or use another one. | `FT.ADD`, `FT.SAFEADD` |


### SEARCH_TYPE_UNSUP

Redis Search found a value of a type that it doesn't support at that point. The description after the code says which value. For example, `Unsupported reply type` means that, in a cluster, `FT.HYBRID` got a reply of an unexpected type from a shard.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_TYPE_UNSUP Tried to index field as a type that is not specified in schema: <field>` | A request asked Redis Search to index the field in the message as a type that the index schema doesn't give it. Only the internal module interface can ask for a type, and nothing in Redis 8.10 does, so writes such as `HSET` never cause this. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_TYPE_UNSUP Unsupported index type` | Redis Search tried to read a document of a type that it can't handle, such as a document of an `ON JSON` index while the module that provides `JSON.SET` isn't loaded. Queries skip such documents instead of failing, so you rarely see this text. | Indexing, shown in FT.INFO |
| `SEARCH_TYPE_UNSUP Unsupported reply type: <reply_type>` | You only get this error in a cluster. A shard answered its part of `FT.HYBRID` with a reply of a type that the coordinator doesn't expect, and the number in the message is that type. Run the command again, and report it to Redis if it continues. | `FT.HYBRID`, `FT.PROFILE` |


### SEARCH_JSON_TYPE_INVALID

A value in a JSON document has a JSON type that the field can't index. For example, a `NUMERIC` field needs a JSON number, and a JSON boolean can only be indexed as a `TAG` field. In these messages, `GEOMETRY` means a `GEOSHAPE` field. To fix it, change the value in the document, or change the type of the field in the index schema.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_JSON_TYPE_INVALID Invalid JSON type` | This is the default text of `SEARCH_JSON_TYPE_INVALID`: a value in a document of an `ON JSON` index has a type that its field can't index, such as text in a `NUMERIC` field. Redis 8.10 adds which types fit, and `FT.INFO` reports it. | Indexing, shown in FT.INFO |
| `SEARCH_JSON_TYPE_INVALID Invalid JSON type: Array type cannot represent GEOMETRY field` | A `GEOSHAPE` field in a JSON document holds an array, but Redis Search indexes one shape per field, as a well-known text (WKT) string. In this message, `GEOMETRY` means `GEOSHAPE`. Store the shape as a string, such as `POINT (2 1)`. | Indexing, shown in FT.INFO |
| `SEARCH_JSON_TYPE_INVALID Invalid JSON type: Boolean type can be represent only TAG field` | A JSON `true` or `false` value is in a field that the index doesn't define as `TAG`. Only `TAG` fields can index booleans, so define the field as `TAG`, or store the value as the type that the field expects. | Indexing, shown in FT.INFO |
| `SEARCH_JSON_TYPE_INVALID Invalid JSON type: Null type is not supported` | Redis Search got a JSON value of an unknown type from the JSON module. Despite the wording, a JSON `null` doesn't cause this error, because Redis Search skips null values, so this points to a mismatch between the two modules. | Indexing, shown in FT.INFO |
| `SEARCH_JSON_TYPE_INVALID Invalid JSON type: Numeric type can represent only NUMERIC field` | A JSON number is in a field that the index doesn't define as `NUMERIC`, such as a `TEXT` or `TAG` field. Store the value as a string, such as `"42"`, or define the field as `NUMERIC`. | Indexing, shown in FT.INFO |
| `SEARCH_JSON_TYPE_INVALID Invalid JSON type: Object type can represent only GEOMETRY fields` | A JSON object is in a field that the index doesn't define as `GEOSHAPE`. Redis Search can't index objects, so point the field's JSONPath at a value inside the object, such as `$.address.city`. | Indexing, shown in FT.INFO |
| `SEARCH_JSON_TYPE_INVALID Invalid JSON type: String type can represent only TEXT, TAG, GEO or GEOMETRY field` | A JSON string is in a `NUMERIC` or `VECTOR` field. Store numbers as JSON numbers, such as `42` rather than `"42"`, and vectors as arrays of numbers. In this message, `GEOMETRY` means `GEOSHAPE`. | Indexing, shown in FT.INFO |


### SEARCH_GEO_COORDINATES_INVALID

A `GEO` field in a document has a longitude or a latitude outside the valid range. The longitude must be from -180 to 180 degrees, and the latitude from -85.05112878 to 85.05112878 degrees. The message shows the longitude first, then the latitude. To fix it, correct the value in the document, and check that the longitude comes first.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_GEO_COORDINATES_INVALID Invalid geo coordinates` | A document's `GEO` field has a longitude or latitude outside the range that Redis can store, so Redis Search doesn't index the document. Longitude must be from -180 to 180, and latitude from about -85.05 to 85.05. Redis 8.10 adds the values to this text, and `FT.INFO` reports it. | Indexing, shown in FT.INFO |
| `SEARCH_GEO_COORDINATES_INVALID Invalid geo coordinates: <longitude>, <latitude>` | Redis Search didn't index a document because a `GEO` field holds a longitude or latitude out of range. The longitude must be from -180 to 180 and the latitude from -85.05112878 to 85.05112878, with the longitude first, as in `lon,lat`. | `FT.ADD`, `FT.SAFEADD` |


### SEARCH_GEO_FORMAT_BAD

No command in Redis 8.10 returns this code. Its default message says that a geo value must have the format `lon lat` or `lon,lat`. A geo value in another format returns [`SEARCH_PARSE_ARGS`](#search_parse_args) with `Invalid geo string` instead.

### SEARCH_VECTOR_BLOB_SIZE_MISMATCH

A vector that you stored in a hash has a different size, in bytes, than the vector field expects. The expected size is the number of dimensions (`DIM`) times the size of one element of the field's `TYPE`, such as 4 bytes for `FLOAT32`. To fix it, store the vector with the `TYPE` and the number of dimensions of the field.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_VECTOR_BLOB_SIZE_MISMATCH Could not add vector with blob size <size> (expected size <size>)` | A hash field that the index defines as `VECTOR` holds a value whose size in bytes, shown in the message, is wrong. The expected size is `DIM` times the size of one element of `TYPE`, for example 4 bytes for `FLOAT32`. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_VECTOR_BLOB_SIZE_MISMATCH Vector blob size does not match expected dimensions` | This is the default text of `SEARCH_VECTOR_BLOB_SIZE_MISMATCH`: a document's vector has a byte length other than `DIM` times the size of the field's `TYPE`. Redis 8.10 sends `Could not add vector with blob size` with both sizes instead, and `FT.INFO` reports it. | Indexing, shown in FT.INFO |


### SEARCH_VECTOR_LEN_BAD

A vector in a JSON document has a different number of elements than the `DIM` of the vector field. The message shows both numbers. To fix it, store the vector with exactly `DIM` elements.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_VECTOR_LEN_BAD Invalid vector length` | This is the default text of `SEARCH_VECTOR_LEN_BAD`: a vector stored as an array in an `ON JSON` index has a different number of elements than the field's `DIM`. Redis 8.10 sends `Invalid vector length` with both numbers instead, and `FT.INFO` reports it. | Indexing, shown in FT.INFO |
| `SEARCH_VECTOR_LEN_BAD Invalid vector length. Expected <dimension>, got <length>` | The JSON array of a `VECTOR` field has a different number of elements than the field's `DIM`. The message shows both numbers. Store vectors with exactly `DIM` elements, or create the index with the right `DIM`. | Indexing, shown in FT.INFO |


## Aggregations

### SEARCH_PROP_NOT_FOUND

A step of `FT.AGGREGATE`, or a `SORTBY`, uses a property that isn't available at that point. A property is available when it's a field of the index, when you load it with `LOAD`, or when an earlier step creates it, for example with `APPLY` and `AS`. To fix it, check the name, load the property with `LOAD`, or move the step after the one that creates the property.

| Error message | Explanation | Returned by |
|---|---|---|
| `` SEARCH_PROP_NOT_FOUND No such property `<property>` `` | The property in the message isn't available at that point of the query. A `GROUPBY` property must be a field of the index or come from an earlier step, and a `HIGHLIGHT` or `SUMMARIZE` field must be an index field. Check the spelling. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `` SEARCH_PROP_NOT_FOUND Property `<property>` not loaded nor in schema `` | `SORTBY` names a property that isn't a field of the index and that no earlier step loads or creates, such as `LOAD` or `APPLY ... AS`. Check the name, which is case-sensitive, or load the property before you sort by it. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_PROP_NOT_FOUND Property not loaded nor in pipeline` | An `APPLY` or `FILTER` expression uses a property that isn't available at that step. You normally get the variant of this message that names the property. Check the name, load fields that aren't `SORTABLE` with `LOAD`, and put the step after the one that creates the property. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `` SEARCH_PROP_NOT_FOUND Property not loaded nor in pipeline: `<property>` `` | The property in the message isn't available at this step of the query. Fields that aren't `SORTABLE` must be loaded first with `LOAD`, for example `LOAD 1 @title`. Also check the name for typos, and that the step comes after the `APPLY` or `REDUCE` that creates the property. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |


### SEARCH_VALUE_NOT_FOUND

An `APPLY` or `FILTER` expression uses a property that has no value in one of the results, for example because the document doesn't have that field. To fix it, check that the property exists first with the `exists()` function, as the message suggests. See [APPLY expressions](https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/aggregations#apply-expressions).

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_VALUE_NOT_FOUND Could not find the value for a parameter name, consider using EXISTS if applicable for <property>` | A result has no value for the property in the message, usually because the document doesn't have that field, so the `APPLY` or `FILTER` expression can't use it. The message says parameter, but it means this property. Check for the value first with `exists()`, such as `FILTER "exists(@age) && @age > 18"`. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_VALUE_NOT_FOUND Value not found in result (not a hard error)` | This is the default text of `SEARCH_VALUE_NOT_FOUND`: an expression in `APPLY` or `FILTER` uses a field that the document doesn't have. Redis 8.10 sends a specific message with the field name instead. Use `exists()` in the expression to handle missing fields. | Search queries |


### SEARCH_EXPR

Redis Search couldn't parse or evaluate an expression, such as the expression of `APPLY` or `FILTER` in `FT.AGGREGATE`, or the `FILTER` of an index in `FT.CREATE`. The message describes the problem, such as an unknown function, the wrong number of arguments, or a syntax error and its position. To fix it, correct the expression. See [APPLY expressions](https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/aggregations#apply-expressions).

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_EXPR Function '<function>' expects <number> arguments, but got <number>` | The function in the message got the wrong number of arguments, and the message says how many it needs. For example, `substr()` takes three arguments: the string, the offset, and the length. | `FT.ADD`, `FT.AGGREGATE`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH` |
| `SEARCH_EXPR Function '<function>' expects between <number> and <number> arguments, but got <number>` | The function in the message got more or fewer arguments than it accepts, and the message gives the allowed range. For example, `split()` takes from 1 to 3 arguments: the string, then optionally the separators and the characters to trim. | `FT.ADD`, `FT.AGGREGATE`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH` |
| `SEARCH_EXPR Missing (or badly formatted) value for expr->func.args->args[ii]` | An argument of a function in your `APPLY` or `FILTER` expression couldn't be parsed; `expr->func.args` in the message means the arguments of a function call. This usually comes from an unknown function or a bare word inside the call. Check each argument for typos, and put quotes around strings and `@` before properties. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_EXPR Missing (or badly formatted) value for expr->inverted.child` | The expression after `!` in your `APPLY` or `FILTER` expression couldn't be parsed; `expr->inverted.child` in the message means what follows `!`. This usually comes from an unknown function or a bare word there. Check it for typos, and put quotes around strings and `@` before properties. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_EXPR Missing (or badly formatted) value for expr->op.left` | The left side of an arithmetic operator, such as `+` or `*`, in your `APPLY` or `FILTER` expression couldn't be parsed; `expr->op.left` in the message means that left side. This usually comes from an unknown function or a bare word there. Check it for typos, and put quotes around strings and `@` before properties. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_EXPR Missing (or badly formatted) value for expr->op.right` | The right side of an arithmetic operator, such as `+`, in your `APPLY` or `FILTER` expression couldn't be parsed; `expr->op.right` in the message means that side. It's usually an unknown function or a bare word, as in `1 + foo(1)`. Check it for typos, quote strings, and put `@` before properties. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_EXPR Missing (or badly formatted) value for expr->pred.left` | The left side of a comparison, such as `==` or `>`, in your `APPLY` or `FILTER` expression couldn't be parsed; `expr->pred.left` in the message means that left side. This usually comes from an unknown function or a bare word there. Check it for typos, and put quotes around strings and `@` before properties. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_EXPR Missing (or badly formatted) value for expr->pred.right` | The right side of a comparison, such as `==` or `>`, in your `APPLY` or `FILTER` expression couldn't be parsed; `expr->pred.right` in the message means that right side. It's usually a bare word, as in `@color == red`. Put quotes around strings, as in `@color == "red"`, and `@` before properties. | `FT.ADD`, `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH`, `FT.SYNUPDATE` |
| `SEARCH_EXPR Parsing/Evaluating dynamic expression failed` | Redis Search couldn't parse or evaluate an expression in `APPLY`, `FILTER`, or the `FILTER` option of `FT.CREATE`, and has no more specific reason. Check the expression's syntax, its function names, and its field names, which need the `@` prefix. | Redis Search commands |
| `SEARCH_EXPR Syntax error at offset <position> near '<token>'` | Redis Search couldn't parse the `APPLY` or `FILTER` expression, or the `FILTER` of `FT.CREATE`, near the offset in the message, counting from 0. Look there for a missing operator, operand, or parenthesis, such as `@price >` with nothing after it, and check that the whole expression is one quoted argument. | `FT.ADD`, `FT.AGGREGATE`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH` |
| `SEARCH_EXPR Syntax error at offset <position> near '<token>': <reason>` | The expression has a syntax error, and the reason after the colon is an earlier problem that probably caused it, such as an unknown function or the wrong number of arguments. Fix the problem in the reason first, and then check the expression near the offset in the message. | `FT.ADD`, `FT.AGGREGATE`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH` |
| `SEARCH_EXPR Unknown function name '<function>'` | The expression calls a function that Redis Search doesn't have, named in the message. Check the spelling against the functions that `APPLY` supports, such as `upper()`, `substr()`, `timefmt()`, and `exists()`. | `FT.ADD`, `FT.AGGREGATE`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH` |
| `SEARCH_EXPR Unknown symbol '<symbol>'` | The expression has a bare word, shown in the message, that isn't a function call, a property, or a string; the only bare word allowed is `NULL`. Put `@` in front of a property name, or quotes around a string, such as `@color == "red"`. | `FT.ADD`, `FT.AGGREGATE`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SEARCH` |


### SEARCH_REDUCER_NOT_FOUND

A `REDUCE` step in a `GROUPBY` names a reducer that doesn't exist. To fix it, check the name of the reducer. See [Supported GROUPBY reducers](https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/aggregations#supported-groupby-reducers).

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_REDUCER_NOT_FOUND No such reducer: <reducer>` | A `REDUCE` step in `GROUPBY` names a reducer that doesn't exist, shown in the message. Check the spelling against the supported reducers, such as `COUNT`, `SUM`, `AVG`, `MIN`, `MAX`, `TOLIST`, and `FIRST_VALUE`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_REDUCER_NOT_FOUND Reducer not found` | This is the default text of `SEARCH_REDUCER_NOT_FOUND`: a `REDUCE` clause of `GROUPBY` names a function that doesn't exist. Redis 8.10 sends `No such reducer` with the name instead. Use a reducer such as `COUNT`, `SUM`, `AVG`, or `TOLIST`. | Search queries |


### SEARCH_REDUCER_ERROR

No command in Redis 8.10 returns this code. Its default message is `Generic reducer error`. Errors in the arguments of a reducer return [`SEARCH_PARSE_ARGS`](#search_parse_args) instead.

### SEARCH_REDUCER_INIT_FAILED

No command in Redis 8.10 returns this code. Its default message says that Redis Search couldn't initialize a reducer.

### SEARCH_AGG_PLAN

No command in Redis 8.10 returns this code. Its default message says that Redis Search couldn't plan the aggregation request.

### SEARCH_CONSTRUCT_PIPELINE

No command in Redis 8.10 returns this code. Its default message says that Redis Search couldn't build the pipeline of steps that runs the query.

### SEARCH_CURSOR_ALLOC_FAILED

No command in Redis 8.10 returns this code. Its default message says that Redis Search couldn't create a cursor. When an index already has too many cursors, you get [`SEARCH_LIMIT_OVER`](#search_limit_over) instead.

## Vector and hybrid queries

In this section, a hybrid query has two meanings. In the parameters of a vector query, such as `HYBRID_POLICY`, it's a vector query with a filter. The [`FT.HYBRID`](https://redis.io/docs/latest/commands/ft.hybrid) command is a different thing. It combines a full-text search with a vector search.

### SEARCH_HYBRID_POLICY_BAD

The `HYBRID_POLICY` parameter of a vector query has a value that Redis Search doesn't know. To fix it, use `BATCHES` or `ADHOC_BF`. See [Filter mode](https://redis.io/docs/latest/develop/ai/search-and-query/vectors#filter-mode).

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_HYBRID_POLICY_BAD invalid hybrid policy was given` | Your filtered vector query sets `HYBRID_POLICY` to a value that doesn't exist. Use `ADHOC_BF` or `BATCHES`. Redis 8.10 sends this text with `(Error parsing vector similarity parameters)` added. | Search queries |
| `SEARCH_HYBRID_POLICY_BAD invalid hybrid policy was given (Error parsing vector similarity parameters)` | Your filtered vector query sets `HYBRID_POLICY` to a value that doesn't exist. Use `HYBRID_POLICY ADHOC_BF` or `HYBRID_POLICY BATCHES`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_HYBRID_ATTR_NON_HYBRID

A vector query without a filter, such as `*=>[KNN 10 @v $vec]`, uses a parameter that only applies to a query with a filter, such as `HYBRID_POLICY` or `BATCH_SIZE`. To fix it, remove the parameter, or add a filter to the query.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_HYBRID_ATTR_NON_HYBRID hybrid query attributes were sent for a non-hybrid query` | Your vector query sets `HYBRID_POLICY` or `BATCH_SIZE`, but it has no filter, so those options don't apply. Add a filter before `=>[KNN ...]`, or remove the options. Redis 8.10 sends this text with `(Error parsing vector similarity parameters)` added. | Search queries |
| `SEARCH_HYBRID_ATTR_NON_HYBRID hybrid query attributes were sent for a non-hybrid query (Error parsing vector similarity parameters)` | Your vector query sets `HYBRID_POLICY` or `BATCH_SIZE`, but it has no filter before `=>[KNN ...]`, so those options don't apply. Add a filter, such as `(@genre:{drama})=>[KNN ...]`, or remove the options. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_ADHOC_BATCH_SIZE_IRRELEVANT

A vector query sets `BATCH_SIZE` and also sets `HYBRID_POLICY` to `ADHOC_BF`. The batch size only applies to the `BATCHES` policy. To fix it, remove `BATCH_SIZE`, or use `HYBRID_POLICY BATCHES`.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_ADHOC_BATCH_SIZE_IRRELEVANT 'batch size' is irrelevant for the selected policy` | Your filtered vector query sets `BATCH_SIZE` together with `HYBRID_POLICY ADHOC_BF`, which doesn't use batches. Remove `BATCH_SIZE`, or use `HYBRID_POLICY BATCHES`. Redis 8.10 sends this text with `(Error parsing vector similarity parameters)` added. | Search queries |
| `SEARCH_ADHOC_BATCH_SIZE_IRRELEVANT 'batch size' is irrelevant for the selected policy (Error parsing vector similarity parameters)` | Your filtered vector query sets `BATCH_SIZE` together with `HYBRID_POLICY ADHOC_BF`, which compares vectors one by one and doesn't use batches. Remove `BATCH_SIZE`, or use `HYBRID_POLICY BATCHES`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_ADHOC_EF_RUNTIME_IRRELEVANT

A vector query sets `EF_RUNTIME` and also sets `HYBRID_POLICY` to `ADHOC_BF`. With `ADHOC_BF`, Redis Search computes the distance to every vector that passes the filter, so `EF_RUNTIME` has no effect. To fix it, remove `EF_RUNTIME`, or don't set `HYBRID_POLICY` to `ADHOC_BF`.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_ADHOC_EF_RUNTIME_IRRELEVANT 'EF_RUNTIME' is irrelevant for the selected policy` | Your filtered vector query sets `EF_RUNTIME` together with `HYBRID_POLICY ADHOC_BF`, which compares vectors one by one and doesn't search the graph. Remove `EF_RUNTIME`, or use `HYBRID_POLICY BATCHES`. Redis 8.10 sends this text with `(Error parsing vector similarity parameters)` added. | Search queries |
| `SEARCH_ADHOC_EF_RUNTIME_IRRELEVANT 'EF_RUNTIME' is irrelevant for the selected policy (Error parsing vector similarity parameters)` | Your filtered vector query sets `EF_RUNTIME` together with `HYBRID_POLICY ADHOC_BF`, which compares vectors one by one and doesn't search the graph. Remove `EF_RUNTIME`, or use `HYBRID_POLICY BATCHES`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_RANGE_ATTR_NON_RANGE

A vector query that isn't a range query uses a parameter that only applies to range queries, such as `EPSILON`. To fix it, remove the parameter, or use a range query with `VECTOR_RANGE`.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_RANGE_ATTR_NON_RANGE range query attributes were sent for a non-range query` | Your `KNN` query sets `EPSILON`, which applies only to vector range queries with `VECTOR_RANGE`. Remove `EPSILON`, or use a range query. Redis 8.10 sends this text with `(Error parsing vector similarity parameters)` added. | Search queries |
| `SEARCH_RANGE_ATTR_NON_RANGE range query attributes were sent for a non-range query (Error parsing vector similarity parameters)` | Your `KNN` query sets `EPSILON`, which applies only to vector range queries with `VECTOR_RANGE`. Remove `EPSILON`, or use a range query. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_VECTOR_NOT_ALLOWED

`FT.HYBRID` found a vector expression, such as `KNN`, where it isn't allowed. The query of the `SEARCH` clause and the `FILTER` of the `VSIM` clause can't contain vector expressions. To fix it, put the vector search in the `VSIM` clause only.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_VECTOR_NOT_ALLOWED Vector expressions are not allowed in FT.HYBRID SEARCH` | The query of the `SEARCH` clause in `FT.HYBRID` contains a vector expression, such as `KNN` or `VECTOR_RANGE`. Put the vector search in the `VSIM` clause, and keep only text, tag, numeric, and other non-vector conditions in `SEARCH`. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_VECTOR_NOT_ALLOWED Vector expressions are not allowed in FT.HYBRID VSIM FILTER` | The `FILTER` of the `VSIM` clause in `FT.HYBRID` contains a vector expression, such as `KNN` or `VECTOR_RANGE`. The filter can only select documents with non-vector conditions, because the vector search itself is the `VSIM` clause. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_VECTOR_NOT_ALLOWED Vector queries are not allowed` | You put a vector query, such as `KNN` or `VECTOR_RANGE`, in a part of `FT.HYBRID` that doesn't accept one: the `SEARCH` query or the `FILTER` of `VSIM`. Put the vector search in `VSIM` only. In Redis 8.10, the message also says which part it was. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_WEIGHT_NOT_ALLOWED

The `FILTER` of the `VSIM` clause in `FT.HYBRID` sets a weight with the `$weight` query attribute. This filter only selects documents and doesn't affect scores, so it can't have a weight. To fix it, remove `$weight` from the filter.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_WEIGHT_NOT_ALLOWED Weight attributes are not allowed` | You set a `$weight` attribute inside the `FILTER` of an `FT.HYBRID` `VSIM` clause, where weights aren't allowed. Remove it. To weight the text and vector results, use `COMBINE LINEAR` with `ALPHA` and `BETA`. Redis 8.10 adds `in FT.HYBRID VSIM FILTER` to this message. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_WEIGHT_NOT_ALLOWED Weight attributes are not allowed in FT.HYBRID VSIM FILTER` | The `FILTER` of the `VSIM` clause in `FT.HYBRID` sets the `$weight` attribute. This filter only selects documents and doesn't affect scores, so remove `$weight` from it. | `FT.HYBRID`, `FT.PROFILE` |


### SEARCH_SAFE_DEPLETER_FAILURE

`FT.HYBRID` couldn't lock the index to collect the results of its subqueries in the background. This can happen when a write to the index is in progress. To fix it, run the query again.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_SAFE_DEPLETER_FAILURE Failed to acquire index lock for background depletion` | `FT.HYBRID` couldn't lock the index to collect results in the background, usually because a write was in progress. Redis 8.10 sends this text with `Please retry.` added. Retry the command. | `FT.HYBRID` |
| `SEARCH_SAFE_DEPLETER_FAILURE Failed to acquire index lock for background depletion. A write operation may be in progress. Please retry.` | `FT.HYBRID` collects the results of its text and vector searches in background threads, and one of them couldn't get a read lock on the index because a write, such as indexing a document, was waiting. Retry the command. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SAFE_DEPLETER_FAILURE Failed to start background depletion` | `FT.HYBRID` couldn't start the background threads that collect the results of its text and vector searches, because their internal state wasn't as expected. This internal failure shouldn't happen. Retry the command. | `FT.HYBRID`, `FT.PROFILE` |


## Resources and limits

### SEARCH_LIMIT_OVER

A value in your command is over a limit of Redis Search, or the command would take the index or the server over one. The description after the code says which limit, and often gives its maximum. Some limits are configuration parameters, such as [`search-max-search-results`](https://redis.io/docs/latest/develop/ai/search-and-query/administration/configuration#search-max-search-results) for the `LIMIT` of `FT.SEARCH`. To fix it, use a smaller value, or raise the limit if it's a configuration parameter.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_LIMIT_OVER <query_type> query string is too long. Maximum allowed length is 1024` | A prefix, suffix, or infix pattern in the query, such as `abc*` or `*abc*`, is longer than 1,024 characters. The message names the kind: `PREFIX`, `SUFFIX`, or `INFIX`. Shorten the pattern, because this limit isn't configurable. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER Aggregate GROUPBY exceeded MAX_AGGREGATE_GROUPS limit of <limit> groups` | `GROUPBY` produced more distinct groups than the limit in the message, which comes from `search-max-aggregate-groups` (1000000 by default). Group by properties with fewer distinct values, filter the results before `GROUPBY`, or raise `search-max-aggregate-groups` with `CONFIG SET`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER BG_INDEX_SLEEP_DURATION_US must be between 1 and 999999 (usleep POSIX limit)` | The value of `BG_INDEX_SLEEP_DURATION_US` is over 999999. Give it a number of microseconds from 1 to 999999. | `FT.CONFIG SET` |
| `SEARCH_LIMIT_OVER BM25STD_TANH_FACTOR must be between 1 and 10000 inclusive` | The value of `BM25STD_TANH_FACTOR` in `FT.CONFIG SET` is over 10000. Give it a whole number from 1 to 10000. | `FT.CONFIG SET` |
| `SEARCH_LIMIT_OVER Cannot add more fields. Declare index with wide fields to allow adding unlimited fields` | `FT.ALTER` can't add another `TEXT` field, because the index already has 32 and wasn't created to hold more. Re-create the index with `MAXTEXTFIELDS` in `FT.CREATE`, so that `FT.ALTER` can add `TEXT` fields up to the limit of 128. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_LIMIT_OVER Cannot sort by more than 8 fields` | The `SORTBY` step of `FT.AGGREGATE` lists more than 8 properties, but Redis Search can sort by 8 properties at most. Remove properties from `SORTBY` until there are 8 or fewer. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER EXPAND format requires dialect 3 or greater` | You used `FORMAT EXPAND` with `DIALECT 1` or `DIALECT 2`. Expanded JSON results need dialect 3 or higher, so set `DIALECT 3` or `DIALECT 4`, or remove `FORMAT EXPAND`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER FIELDS count must be in [1, <limit>]` | The number after `FIELDS` in the `COLLECT` reducer is 0, negative, or larger than the limit in the message. Give the number of fields that follow, from 1 up to that limit, or use `FIELDS *` to collect all the fields that are available. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER INDEX_CURSOR_LIMIT of <limit> has been reached for an index` | The index already has as many open cursors as `search-index-cursor-limit` allows (128 by default), even after Redis Search removed the expired ones. Read each cursor to the end or delete it with `FT.CURSOR DEL`, use a shorter `MAXIDLE`, or raise the limit with `CONFIG SET`. | `FT.AGGREGATE`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER KNN K parameter is too large, max supported K value is <limit>` | You only get this in a cluster. The K of a K nearest neighbors (KNN) vector query, the number of results it asks for, is greater than the maximum in the message, 288230376151711744. Use a smaller K. | `FT.AGGREGATE`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER LIMIT count exceeds maximum of <limit>` | The count in the `LIMIT` of the `COLLECT` reducer is over `search-max-aggregate-results`, the maximum in the message. Collect fewer entries for each group, or raise `search-max-aggregate-results` with `CONFIG SET`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER Limit exceeded` | This is the default text of `SEARCH_LIMIT_OVER`, which means that a value is larger than Redis Search allows, such as a `LIMIT` above `search-max-search-results`. Redis 8.10 sends a specific message that names the limit instead of this text. | Redis Search commands |
| `SEARCH_LIMIT_OVER LIMIT exceeds maximum of <limit>` | The number of results that you asked for in `LIMIT` is over the maximum in the message. For `FT.SEARCH` and `FT.HYBRID`, the maximum is `search-max-search-results` (1000000 by default), and for `FT.AGGREGATE` it's `search-max-aggregate-results`. Ask for fewer results per call, or raise the parameter with `CONFIG SET`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER LIMIT offset exceeds maximum of <limit>` | The offset in the `LIMIT` of the `COLLECT` reducer is over `search-max-aggregate-results`, the maximum in the message. Use a smaller offset, or raise `search-max-aggregate-results` with `CONFIG SET`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER Maximum number of indexes (<limit>) reached` | The database already has as many indexes as Redis Search allows, 200,000, so `FT.CREATE` can't add another. Drop indexes that you no longer need with `FT.DROPINDEX`. This limit isn't a configuration parameter. | `FT.CREATE` |
| `SEARCH_LIMIT_OVER Memory limit for indexing cannot be greater then 100%` | `_BG_INDEX_MEM_PCT_THR` is a percentage of memory, so it can't be over 100. Give it a value from 0 to 100. | `FT.CONFIG SET` |
| `SEARCH_LIMIT_OVER Number of prefixes (<number>) exceeds maximum allowed (1000000)` | You gave `FT.CREATE` more than 1,000,000 key prefixes after `PREFIX`; the message shows how many. Use fewer prefixes, for example a shorter prefix that several groups of keys share. | `FT.CREATE` |
| `SEARCH_LIMIT_OVER Number of worker threads cannot exceed <limit>` | You asked for more worker threads than Redis Search allows, and the message gives the maximum (16). Set `WORKERS` to a number from 0 up to that maximum. | `FT.CONFIG SET` |
| `SEARCH_LIMIT_OVER OFFSET exceeds maximum of <limit>` | The offset in `LIMIT` is over `search-max-search-results` (1000000 by default), the maximum in the message, and this limit applies to `FT.AGGREGATE` too. Make the query match fewer results, read `FT.AGGREGATE` results with `WITHCURSOR` instead of an offset, or raise `search-max-search-results` with `CONFIG SET`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER OFFSET/LIMIT too large for optimizer allocation` | Redis Search couldn't allocate memory to keep the top results of a sorted query, because the `LIMIT` offset plus count is too large. Use a smaller `LIMIT`. The usual `LIMIT` checks, against `search-max-search-results`, normally reject such values first. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER Schema is currently limited to <number> fields` | Redis Search couldn't add another field to the schema. In Redis Search 8.10 this check can't fail, so you shouldn't see this message. The real limits, 1,024 fields and 128 `TEXT` fields, have their own messages. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_LIMIT_OVER Schema is limited to 1024 fields` | Your `FT.CREATE` or `FT.ALTER` would give the index more than 1,024 fields, the most that one index can have. Index fewer fields, or split them across several indexes. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_LIMIT_OVER Schema is limited to 1024 Sortable fields` | Redis Search couldn't add another `SORTABLE` field. In Redis Search 8.10 the limit of 1,024 fields in a schema is always reached first, so you see `Schema is limited to 1024 fields` instead of this message. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_LIMIT_OVER Schema is limited to <limit> TEXT fields` | Your `FT.CREATE` or `FT.ALTER` would give the index more indexed `TEXT` fields than the limit in the message, which is 128 on 64-bit systems. Index fewer `TEXT` fields, use `TAG` for values that you match exactly, or mark some fields `NOINDEX`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_LIMIT_OVER SORTBY exceeds maximum of 8 fields` | The `SORTBY` of the `COLLECT` reducer lists more than 8 properties, but it can sort by 8 at most. Remove properties until there are 8 or fewer. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `` SEARCH_LIMIT_OVER The `offset` of the LIMIT must be 0 when `num` is 0 `` | You used `LIMIT` with a count of 0 and an offset other than 0. `LIMIT 0 0` returns only the number of matching documents, so the offset must also be 0. Use `LIMIT 0 0` to count results, or give a count above 0 to page through them. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_LIMIT_OVER Value exceeds maximum possible aggregate groups` | The value of `MAX_AGGREGATE_GROUPS` is over the maximum of 67108864. Use a smaller value. With `CONFIG SET`, the same setting is `search-max-aggregate-groups`. | `FT.CONFIG SET` |
| `SEARCH_LIMIT_OVER Value exceeds maximum possible document table size` | The value of `MAXDOCTABLESIZE` is over the maximum of 100000000. You can set `MAXDOCTABLESIZE` only when Redis Search loads, so this message appears in the Redis log and the module doesn't load. Fix the value in the module arguments. | `FT.CONFIG SET` |
| `SEARCH_LIMIT_OVER Vector index element size <size> exceeded maximum size allowed by server limit which is <limit>` | One vector of this field needs more memory than Redis Search allows for a block of vectors: a tenth of `maxmemory`, or of system memory, unless `search-vss-max-resize` sets the limit. The last number is how many vectors fit, not a size. Raise that limit, or use a smaller `DIM`. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_LIMIT_OVER Wildcard query string is too long. Maximum allowed length is 1024` | A wildcard pattern in the query, such as `w'*abc*'`, is longer than 1,024 characters. Shorten the pattern, because this limit isn't configurable. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_TIMEOUT

The query ran longer than its timeout. The timeout is the `TIMEOUT` argument of the query, or the `search-timeout` configuration parameter if the query has no `TIMEOUT`. You get this error when the policy of [`search-on-timeout`](https://redis.io/docs/latest/develop/ai/search-and-query/administration/configuration#search-on-timeout) is `FAIL`. With the other policies, Redis returns the results that it found before the timeout. To fix it, make the query match fewer documents, or give it more time with `TIMEOUT`.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_TIMEOUT Depleting timed out` | `FT.HYBRID` with `WITHCURSOR`, which is also how shards run it in a cluster, timed out while it collected the results of its subqueries. Unless `search-on-timeout` is `RETURN`, this fails the query. Give it more time with `TIMEOUT`, or make it match fewer documents. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_TIMEOUT Timeout limit was reached` | The query ran longer than its timeout, and the `search-on-timeout` policy is `FAIL`, so you get an error instead of partial results. The timeout is the query's `TIMEOUT` argument, or `search-timeout` (500 milliseconds by default). Make the query match fewer documents, or give it more time with `TIMEOUT`. | `FT.AGGREGATE`, `FT.CURSOR READ`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_OOM

Redis was out of memory (OOM) when the query started, so Redis Search didn't run the query. Out of memory means that Redis used more memory than its `maxmemory` limit. You get this error when the policy of [`search-on-oom`](https://redis.io/docs/latest/develop/ai/search-and-query/administration/configuration#search-on-oom) is `FAIL`. To fix it, free up memory or increase `maxmemory`.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_OOM Failed to process shard responses, first error: <error>, total error count: <number>` | You only get this error in a cluster. At least one shard was out of memory when it ran its part of `FT.HYBRID`, and `search-on-oom` is `fail`, so the whole command fails. Free memory or raise `maxmemory` on the shards, or set `search-on-oom` to `return` to get results from the other shards. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_OOM Not enough memory available to execute the query` | Redis was using more memory than its `maxmemory` limit when the query started, and the `search-on-oom` policy is `fail`, so Redis Search didn't run the query. Free some memory or raise `maxmemory`, and then run the query again. | `FT.AGGREGATE`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_INDEX_BG_OOM_FAIL

When you create an index, or change it with `FT.ALTER`, Redis Search indexes the existing keys in a background scan. This scan stopped because Redis ran out of memory. After that, the index doesn't index new documents either, and `FT.INFO` shows this message as the `last indexing error`. To fix it, free up memory or increase `maxmemory`, and then drop the index and create it again.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_INDEX_BG_OOM_FAIL Index background scan did not complete due to OOM` | The background scan that indexes existing keys stopped because Redis was running out of memory. Redis 8.10 sends this text with `New documents will not be indexed.` added. Free memory or raise `maxmemory`, and then drop and re-create the index. | Indexing, shown in FT.INFO |
| `SEARCH_INDEX_BG_OOM_FAIL Index background scan did not complete due to OOM. New documents will not be indexed.` | The background scan that indexes existing keys stopped because Redis was running out of memory, and the index now skips every new or changed document. `FT.INFO` shows this. Free memory or raise `maxmemory`, and then drop and re-create the index. | `FT.ALTER`, `FT.CREATE`, `FT.SYNUPDATE` |


## Clusters

### ERRCLUSTER

You only get this error in a cluster. Redis Search doesn't have the list of shards in the cluster yet, so it can't send the command to them. To fix it, wait until the cluster is ready, and then run the command again.

| Error message | Explanation | Returned by |
|---|---|---|
| `ERRCLUSTER Uninitialized cluster state, could not perform command` | Redis Search doesn't know the shards of the cluster yet, so it can't send the command to them. This happens right after startup or a change to the cluster. Wait until the cluster is ready, and run the command again. | `FT.AGGREGATE`, `FT.ALIASADD`, `FT.ALTER`, `FT.CREATE`, `FT.CURSOR DEL`, `FT.CURSOR READ`, `FT.DROPINDEX`, `FT.HYBRID`, `FT.INFO`, `FT.MGET`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK`, `FT.TAGVALS` |


### SEARCH_CLUSTER_NO_RESPONSES

You only get this error in a cluster. `FT.INFO` sent the request to the shards, but no shard replied. To fix it, check that the shards are running and reachable, and then run the command again.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_CLUSTER_NO_RESPONSES no responses received` | You only get this error in a cluster. `FT.INFO` or `FT._LIST` sent the request to the shards, but no shard replied. Check that the shards are running and reachable, and then run the command again. | `FT.INFO` |


### SEARCH_SLOTS_UNAVAIL

You only get this error in a cluster. A shard got a query for hash slots that it doesn't have at the moment, for example while slots move to another shard. To fix it, run the query again when the slot migration is over.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_SLOTS_UNAVAIL Failed to process shard responses, first error: <error>, total error count: <number>` | You only get this error in a cluster. At least one shard didn't own all the hash slots that `FT.HYBRID` needed, usually because slots were moving to another shard. Run the command again when the slot migration is over. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_SLOTS_UNAVAIL Query requires unavailable slots` | You only get this error in a cluster. A shard got a query for hash slots that it doesn't own at the moment, usually because slots are moving to another shard. Run the query again when the slot migration is over. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_INDEX_MISMATCH

You only get this error in a cluster. On one of the shards, the index has different key prefixes than the index that the query was sent for. This can happen when the index is created again with other prefixes while the query runs. To fix it, run the query again. If the error continues, check that the index has the same definition on every shard.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_INDEX_MISMATCH Index mismatch: Shard index is different than queried index` | You only get this error in a cluster. On a shard, the index has other key prefixes than the coordinator expected, for example because it was created again with new prefixes while the query ran. Run the query again, and if the error continues, check that the index is the same on every shard. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |


### SEARCH_DIST_FAILED

No command in Redis 8.10 returns this code. Its default message says that Redis Search couldn't distribute the operation to the shards. When a command can't reach the shards, the message is `Could not distribute command` or `Could not send query to cluster` instead.

## Redis Flex and disk indexes

Some of these messages call an index that uses Redis Flex a disk index.

### SEARCH_FLEX_LIMIT_NUMBER_OF_INDEXES

You only get this error when you create an index that uses Redis Flex. The database already has as many indexes as Redis Flex allows. To fix it, drop an index that you no longer need with [`FT.DROPINDEX`](https://redis.io/docs/latest/commands/ft.dropindex).

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_FLEX_LIMIT_NUMBER_OF_INDEXES Flex index limit was reached` | This is the default text of the code that Redis Flex sends when you already have the most indexes it allows, which is 10. Redis 8.10 sends `Max number of indexes reached for Flex indexes` with the count instead. Drop an index that you no longer need. | Redis Search commands |
| `SEARCH_FLEX_LIMIT_NUMBER_OF_INDEXES Max number of indexes reached for Flex indexes: <number>` | You only get this when Redis Search runs on Redis Flex. `FT.CREATE` can't add an index, because the database already has as many indexes as Redis Flex allows. Drop an index that you no longer need with `FT.DROPINDEX`. | `FT.CREATE` |


### SEARCH_FLEX_UNSUPPORTED_FIELD

You only get this error from an index that uses Redis Flex. The schema in `FT.CREATE` has a field type that Redis Flex doesn't support, such as `GEO` or `GEOSHAPE`. To fix it, remove that field from the schema.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_FLEX_UNSUPPORTED_FIELD <field_type> fields are not supported in Flex indexes` | Your schema has a field type that Redis Flex can't index, named in the message. Flex indexes don't support `GEO` or `GEOSHAPE` fields. Use only `TEXT`, `TAG`, `NUMERIC`, and `VECTOR` fields. | `FT.ALTER`, `FT.CREATE` |
| `SEARCH_FLEX_UNSUPPORTED_FIELD Unsupported field for Flex index` | This is the default text of the code that Redis Flex sends for a field type that it can't index. Redis 8.10 names the type instead, as in `GEO fields are not supported in Flex indexes`. Remove `GEO` and `GEOSHAPE` fields from the schema. | Redis Search commands |


### SEARCH_FLEX_UNSUPPORTED_FT_CREATE_ARGUMENT

You only get this error from an index that uses Redis Flex. `FT.CREATE` has an argument that Redis Flex doesn't support, and the message names it. To fix it, remove that argument.

| Error message | Explanation | Returned by |
|---|---|---|
| `` SEARCH_FLEX_UNSUPPORTED_FT_CREATE_ARGUMENT Unsupported argument for Flex index: `<argument>` `` | Your `FT.CREATE` uses an option that Redis Flex indexes don't support, named in the message, such as `NOOFFSETS`, `NOFIELDS`, `NOFREQS`, `NOHL`, `MAXTEXTFIELDS`, `TEMPORARY`, `PAYLOAD_FIELD`, or `INDEXALL`. Remove that option. | `FT.CREATE` |
| `SEARCH_FLEX_UNSUPPORTED_FT_CREATE_ARGUMENT Unsupported FT.CREATE argument for Flex index` | This is the default text of the code that Redis Flex sends for an `FT.CREATE` option that it doesn't support. Redis 8.10 names the option instead, such as `NOOFFSETS` or `TEMPORARY`. Remove that option from `FT.CREATE`. | Redis Search commands |


### SEARCH_FLEX_UNSUPPORTED_QUERY

You only get this error from an index that uses Redis Flex. The query uses a kind of `TAG` query that Redis Flex doesn't support, such as a prefix, suffix, or wildcard match, and the message names it. To fix it, rewrite the query without that kind of match.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_FLEX_UNSUPPORTED_QUERY <query_type> queries are not supported on Flex indexes` | You only get this from an index that uses Redis Flex, which doesn't support the kind of `TAG` match named in the message: a prefix, suffix, or infix match such as `{abc*}`, a wildcard match, or a lexical range. Match exact `TAG` values instead. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_FLEX_UNSUPPORTED_QUERY Unsupported query type for Flex indexes` | This is the default text of the code that Redis Flex sends for a kind of query that it can't run. Redis 8.10 names the kind instead, such as tag prefix, suffix, or wildcard queries. Rewrite the query without that syntax. | Search queries |


### SEARCH_FLEX_UNSUPPORTED_ARGUMENT

You only get this error from an index that uses Redis Flex. The command uses an argument that Redis Flex doesn't support, such as `HIGHLIGHT`, `SLOP`, or `WITHCURSOR`, or a `SORTBY` that doesn't sort by vector distance. The same code covers `FT.SEARCH` and `FT.AGGREGATE` inside a `MULTI`/`EXEC` transaction or a Lua script. To fix it, remove the argument that the message names. In a transaction or a script, follow the advice in the message, or run the command outside it.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_FLEX_UNSUPPORTED_ARGUMENT <argument> is not supported in Redis Flex` | Your command uses an option that Redis Flex doesn't support, named in the message: `WITHSUFFIXTRIE` in a schema, or `WITHCURSOR`, `SUMMARIZE`, `HIGHLIGHT`, `WITHOUTCOUNT`, `SLOP`, `INORDER`, or `DIALECT 4` in a query. Remove that option. | `FT.AGGREGATE`, `FT.ALTER`, `FT.CREATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_FLEX_UNSUPPORTED_ARGUMENT FT.AGGREGATE in a context that cannot block (MULTI/EXEC or Lua scripts) is not supported in Redis Flex` | You ran `FT.AGGREGATE` on a Redis Flex index inside a `MULTI`/`EXEC` transaction or a Lua script. There, Redis can't block the client while it reads documents from disk, so Redis Flex rejects every `FT.AGGREGATE`. Run the aggregation as a separate command, outside the transaction or script. | `FT.AGGREGATE`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_FLEX_UNSUPPORTED_ARGUMENT FT.SEARCH with field return in a context that cannot block (MULTI/EXEC or Lua scripts) is not supported in Redis Flex; use NOCONTENT or RETURN 0` | You ran `FT.SEARCH` on a Redis Flex index inside a `MULTI`/`EXEC` transaction or a Lua script, and the query returns document fields. Loading them from disk would block the client, which isn't possible there. Add `NOCONTENT` or `RETURN 0` and remove any `LOAD`, or run the query outside the transaction or script. | `FT.AGGREGATE`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_FLEX_UNSUPPORTED_ARGUMENT SORTBY in Redis Flex is restricted to sorting results by vector distance in vector queries. Otherwise, results are always sorted by the default document score.` | On a Redis Flex index, `SORTBY` can only sort by the distance field of a vector (`KNN`) query. Remove `SORTBY` to get results sorted by score, or sort by the distance field, which is `__<vector_field>_score` unless you named it with `AS`. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_FLEX_UNSUPPORTED_ARGUMENT Unsupported argument for Redis Flex` | This is the default text of the code that Redis Flex sends when a command uses an option that it doesn't support. Redis 8.10 names the option instead, as in `HIGHLIGHT is not supported in Redis Flex`. Remove that option. | Redis Search commands |


### SEARCH_FLEX_SEARCH_LOAD_UNSUPPORTED

No command in Redis 8.10 returns this code. Its default message says that Redis Flex doesn't support `LOAD`.

### SEARCH_FLEX_SEARCH_NOCONTENT_OR_RETURN_0_REQUIRED

No command in Redis 8.10 returns this code. Its default message says that `FT.SEARCH` needs `NOCONTENT` or `RETURN 0` in Redis Flex. In Redis 8.10, an `FT.SEARCH` that returns fields inside a transaction or a script gets [`SEARCH_FLEX_UNSUPPORTED_ARGUMENT`](#search_flex_unsupported_argument) instead, with the same advice.

### SEARCH_DISK_CREATION

You only get this error from an index that uses Redis Flex. `FT.CREATE` couldn't create or open the disk storage for the new index. This points to a problem on the server rather than in your command.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_DISK_CREATION Could not create disk index` | This is the default text of `SEARCH_DISK_CREATION`, which means that Redis Flex couldn't create or open the disk storage of an index. Redis 8.10 doesn't send this text; `FT.CREATE` sends `Could not open disk index` instead. | Redis Search commands |
| `SEARCH_DISK_CREATION Could not open disk index` | Redis Flex couldn't open the disk storage of the index that you're creating, so `FT.CREATE` failed. This is an internal storage failure. Check the server log and the disk, and then retry. | `FT.CREATE` |


### SEARCH_DISK_ITERATOR_CREATION

You only get this error from an index that uses Redis Flex. While it ran the query, Redis Search couldn't start reading the values of a `NUMERIC` field from disk. The description after the code is the error that the disk storage reported.

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_DISK_ITERATOR_CREATION <error>` | Redis Flex couldn't start reading the disk part of an index for a numeric filter in your query, so the query stopped. The text after the code gives the reason. This is an internal failure; retry the query, and check the server log if it keeps happening. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_DISK_ITERATOR_CREATION Could not create disk iterator` | This is the default text of `SEARCH_DISK_ITERATOR_CREATION`, which means that Redis Flex couldn't start reading an index on disk for a query. Redis 8.10 sends the specific reason instead of this text. Retry the query. | Search queries |


## Other codes

### SEARCH_GENERIC

This is the general code for errors that have no more specific code. Its messages cover unrelated problems, such as a failure to index a document, a failure to reach the shards of a cluster, or an internal error while a query runs. The description after the code says what went wrong. `FT.ALIASADD` and `FT.ALIASUPDATE` also use this code for the permission error that other commands return as [`NOPERM`](#noperm).

| Error message | Explanation | Returned by |
|---|---|---|
| `SEARCH_GENERIC <processor> RP type not found in stream or tried to insert after last RP` | This message comes from `PAUSE_BEFORE_RP_N` or `PAUSE_AFTER_RP_N`, options of the internal `_FT.DEBUG` testing command. The pipeline step named in the message isn't in the query's pipeline, or it's the last step. Normal queries never send this. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_GENERIC cannot operate on a JSON index as RedisJSON is not loaded` | The index was created `ON JSON`, but the JSON module isn't loaded, so Redis Search can't read the documents. This usually means Redis runs without its bundled JSON module. Load the module, for example with `loadmodule` in the configuration file, and restart Redis. | Redis Search commands |
| `SEARCH_GENERIC Contains query on fields without WITHSUFFIXTRIE support` | The query uses a suffix, contains, or wildcard match, such as `*ell*` or `w'*ell*'`, on a `TEXT` field without `WITHSUFFIXTRIE`, while another field of the index has it. Query only fields with `WITHSUFFIXTRIE`, or create the index again with it on this field. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_GENERIC Could not open geoshape index for indexing` | Redis Search couldn't open the internal index of a `GEOSHAPE` field to add a document, so it didn't index the document. This is an internal error, not a problem with the document, and `FT.INFO` shows it as the last indexing error. Report it to Redis if it repeats. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Could not open numeric index for indexing` | Redis Search couldn't open the internal index of a `NUMERIC` or `GEO` field to add a document, so it didn't index the document. This is an internal error, not a problem with the document, and `FT.INFO` shows it as the last indexing error. Report it to Redis if it repeats. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Could not open tag index for indexing` | Redis Search couldn't open the internal index of a `TAG` field while it indexed a document. In Redis 8.10 this can't normally happen, so it points to a bug or a server problem rather than to your data. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Could not open vector for indexing` | Redis Search couldn't create the vector index of a `VECTOR` field when it indexed the first vector into it. This points to a problem on the server, such as a failed memory allocation or, with Redis Flex, a disk storage problem, rather than to your data. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Could not parse numeric index value` | A new value for a `NUMERIC` `SORTABLE` field wasn't a number when Redis Search updated the document's sort values. This belongs to the partial update path of the deprecated `FT.ADD ... REPLACE PARTIAL`, which Redis 8.10 no longer runs, so you shouldn't see it. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC could not parse redisearch results` | You only get this in a cluster. A shard replied to `FT.SEARCH` with something the coordinator couldn't read, and no shard error explains it. This can happen when shards run different versions of Redis Search, so check the versions and run the query again. | `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_GENERIC Could not send query to cluster` | You only get this in a cluster. The coordinator got no replies from the shards for `FT.SEARCH`, so it couldn't run the query. Check that the shards are running and reachable, and run the query again. | `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_GENERIC Couldn't load document metadata` | Redis Search found the document in the index but couldn't read its stored metadata during a partial update. This belongs to the partial update path of the deprecated `FT.ADD ... REPLACE PARTIAL`, which Redis 8.10 no longer runs, so you shouldn't see it. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Couldn't load old document` | During a partial update, Redis Search couldn't find the existing document in the index. This belongs to the partial update path of the deprecated `FT.ADD ... REPLACE PARTIAL`, which Redis 8.10 no longer runs, so you shouldn't see it. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Cursor not found, id: <cursor_id>` | In a cluster, `FT.CURSOR READ` found no idle cursor with the ID in the message. A cursor is removed when you read its last results, when you delete it with `FT.CURSOR DEL`, or when it's idle longer than its `MAXIDLE` time. Run `FT.AGGREGATE` with `WITHCURSOR` again to get a new cursor. | `FT.CURSOR READ` |
| `SEARCH_GENERIC Document indexing failed; disk write batch aborted` | You only get this from an index that uses Redis Flex. Redis Search couldn't index a field of the document, so it discarded the disk writes for the whole document. The field statistics of `FT.INFO` show the error of the field that failed. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Expected <processor> processor at end of pipeline, found <processor>` | `FT.PROFILE` with `HYBRID` found an unexpected internal processing step at the end of a subquery. This is an internal consistency check, so it points to a bug in Redis Search rather than to your command. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_GENERIC Expected first reply as integer. Have <reply_type>` | You only get this error in a cluster. A shard answered its part of `FT.SPELLCHECK` in a format that the coordinator doesn't expect; the number in the message is the type of reply that it got. This can happen when shards run different versions of Redis Search. Run the command again, and report it if it continues. | `FT.SPELLCHECK` |
| `SEARCH_GENERIC Expected total_docs as integer. Have <reply_type>` | You only get this error in a cluster. A shard answered its part of `FT.SPELLCHECK` without the document count that the coordinator expects; the number in the message is the type of reply that it got. This can happen when shards run different versions of Redis Search. Run the command again, and report it if it continues. | `FT.SPELLCHECK` |
| `SEARCH_GENERIC Failed to allocate memory for multi-vector field` | Redis Search couldn't compute the memory needed for all the vectors of a multi-value `VECTOR` field in a JSON document, because the size overflowed. This can't happen with realistic data, so you shouldn't see this message. | Indexing, shown in FT.INFO |
| `SEARCH_GENERIC Failed to allocate memory for text field` | Redis Search couldn't compute the memory needed for all the values of a `TEXT` or `TAG` field in a JSON document, because the size overflowed. This can't happen with realistic data, so you shouldn't see this message. | Indexing, shown in FT.INFO |
| `SEARCH_GENERIC Failed to allocate memory for vector` | Redis Search couldn't allocate memory for a vector from a JSON document. This only happens if a memory allocation fails, which normally stops Redis instead, so you shouldn't see this message. | Indexing, shown in FT.INFO |
| `SEARCH_GENERIC Failed to build hybrid pipeline` | `FT.HYBRID` couldn't set up the steps that run its subqueries, and no more specific error was recorded. This usually points to an internal problem. Check the command against the `FT.HYBRID` syntax, and run it again. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_GENERIC Failed to commit disk write batch` | You only get this from an index that uses Redis Flex. Redis Search couldn't save the document's index entries to disk storage, which points to a problem on the server rather than in your data. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Failed to communicate with shards` | You only get this error in a cluster. `FT.HYBRID` couldn't start sending its query to the shards. Check that all shards are running and reachable, and then run the command again. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_GENERIC Failed to create disk snapshot for index '<index>'` | Redis Flex couldn't take the point-in-time snapshot of the index's data on disk that the query needs, so the query stopped. This is an internal failure of disk-backed indexes. Retry the query, and check the server log if it keeps happening. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_GENERIC Failed to create pause RP or another debug RP is already set` | This message comes from `PAUSE_BEFORE_RP_N` or `PAUSE_AFTER_RP_N`, options of the internal `_FT.DEBUG` testing command: another debug pause is already set. Let the paused query finish before you set another pause. Normal queries never send this. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_GENERIC Failed to deplete set of results, rc=<code>` | `FT.HYBRID` with `WITHCURSOR`, which is also how shards run it in a cluster, couldn't collect the results of its subqueries. The number is an internal result code. This points to an internal error rather than to your command, so run it again. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_GENERIC Failed to get value from iterator` | Redis Search couldn't build the sort value of a `SORTABLE` field whose JSONPath returns several values, so it didn't index the document. This usually points to an internal problem rather than to your data. | Indexing, shown in FT.INFO |
| `SEARCH_GENERIC Failed to merge hybrid subquery results` | `FT.HYBRID` couldn't combine the results of its text search and its vector search into one result. In Redis Search 8.10 this step can't fail, so you shouldn't see this message. If you do, retry the command. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_GENERIC Failed to process shard responses, first error: <error>, total error count: <number>` | You only get this error in a cluster. One or more shards returned an error for their part of `FT.HYBRID`, and the message shows the first error and how many there were. Fix the problem that the first error describes, or, if it's a connection problem, check that the shards are reachable. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_GENERIC Generic error evaluating the query` | Redis Search hit an error that has no more specific message. In a cluster, it can mean that the coordinator couldn't start sending the query to the shards. Run the command again, and if it keeps failing, check that all shards are running and reachable. | `FT.ADD`, `FT.AGGREGATE`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD`, `FT.SPELLCHECK` |
| `SEARCH_GENERIC Generic error evaluating the query (Error parsing vector similarity parameters)` | Redis Search couldn't apply the options of your vector query, inside `=>[KNN ...]` or `VECTOR_RANGE`, and has no specific reason. Check each option's name and value, and remove options that the field's algorithm doesn't use. | `FT.AGGREGATE`, `FT.EXPLAIN`, `FT.EXPLAINCLI`, `FT.HYBRID`, `FT.PROFILE`, `FT.SEARCH` |
| `SEARCH_GENERIC GEOMETRY field does not support array type` | A JSON array can't be indexed as a `GEOSHAPE` field. Redis 8.10 returns `Invalid JSON type: Array type cannot represent GEOMETRY field` for this instead, so you shouldn't see this message. Store one shape as a well-known text (WKT) string. | Indexing, shown in FT.INFO |
| `SEARCH_GENERIC Invalid UTF8` | A new value for a `SORTABLE` field wasn't valid Unicode text, so Redis Search couldn't normalize it for sorting. This belongs to the partial update path of the deprecated `FT.ADD ... REPLACE PARTIAL`, which Redis 8.10 no longer runs, so you shouldn't see it. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Invalid vector element at index <position>` | An element of the JSON array of a `VECTOR` field isn't a valid number for the field's `TYPE`. The message gives its position, counting from 0. Elements must be numbers, and for `INT8` and `UINT8` they must be whole numbers. | Indexing, shown in FT.INFO |
| `SEARCH_GENERIC Invalid vector elements type - expected <vector_type>, got <json_type>` | The JSON array of an `INT8` or `UINT8` `VECTOR` field holds decimal numbers, such as `[0.5, 1.5]`, but these types need whole numbers. The number after `got` is an internal type code. Store whole numbers, or use a float `TYPE` such as `FLOAT32`. | Indexing, shown in FT.INFO |
| `SEARCH_GENERIC Invalid vector similarity algorithm` | A `VECTOR` field uses an algorithm that Redis Search doesn't know when it reads a vector from a JSON document. Every algorithm that `FT.CREATE` accepts is handled, so this points to a bug rather than to your data. | Indexing, shown in FT.INFO |
| `SEARCH_GENERIC No subqueries in hybrid request` | `FT.HYBRID` tried to start cursors for a request that has no subqueries. Every `FT.HYBRID` request has exactly two subqueries, so this can't happen in Redis 8.10 and points to a bug in Redis Search. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_GENERIC NOPERM User does not have the required permissions to query the index` | You only get this on Redis Software and Redis Cloud. Your user's access control list (ACL) rules don't allow access to every key prefix of the index, so `FT.ALIASADD` or `FT.ALIASUPDATE` can't point an alias at it. Give the user access to those prefixes. | `FT.ALIASADD`, `FT.ALIASUPDATE` |
| `SEARCH_GENERIC Numeric indexing failed` | You only get this from an index that uses Redis Flex. Redis Search couldn't write a `NUMERIC` value of the document to disk storage, which points to a problem on the server rather than in your data. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Object type is not supported` | A `GEOSHAPE` field in a JSON document holds a JSON object, such as GeoJSON. Redis Search 8.10 can't index objects in any field, so store the shape as a well-known text (WKT) string, such as `POINT (2 1)`. | Indexing, shown in FT.INFO |
| `SEARCH_GENERIC Requested to index field twice` | During a partial update, the same `SORTABLE` field appeared twice in the field list. This belongs to the partial update path of the deprecated `FT.ADD ... REPLACE PARTIAL`, which Redis 8.10 no longer runs, so you shouldn't see it. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Tag indexing failed` | You only get this from an index that uses Redis Flex. Redis Search couldn't write the `TAG` values of the document to disk storage, which points to a problem on the server rather than in your data. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC Unexpected depleter type: expected <processor>, got <processor>` | `FT.HYBRID` found an unexpected internal processing step at the end of a subquery when it set up cursors. This is an internal consistency check, so it points to a bug in Redis Search rather than to your command. | `FT.HYBRID`, `FT.PROFILE` |
| `SEARCH_GENERIC Unsupported field type` | The JSONPath of a `GEOSHAPE` field returns more than one value, for example because it has a wildcard such as `$.shapes[*]`. Redis Search can't index several shapes in one field, so use a JSONPath that returns a single well-known text (WKT) string. | Indexing, shown in FT.INFO |
| `SEARCH_GENERIC Unsupported sortable type` | During a partial update, a `SORTABLE` field had a type that the update couldn't store as a sort value. This belongs to the partial update path of the deprecated `FT.ADD ... REPLACE PARTIAL`, which Redis 8.10 no longer runs, so you shouldn't see it. | `FT.ADD`, `FT.SAFEADD` |
| `SEARCH_GENERIC wrong reply type. Expected array. Got <reply_type>` | You only get this error in a cluster. A shard answered its part of `FT.SPELLCHECK` with something other than the array that the coordinator expects, and the number in the message is the type of reply that it got. Run the command again, and report it to Redis if it continues. | `FT.SPELLCHECK` |
| `SEARCH_GENERIC wrong reply type. Expected map. Got <reply_type>` | You only get this error in a cluster. A shard answered its part of `FT.SPELLCHECK` with something other than the map that the coordinator expects, and the number in the message is the type of reply that it got. Run the command again, and report it to Redis if it continues. | `FT.SPELLCHECK` |


### ERR

Redis Search uses the general `ERR` code for a few errors. `ERR wrong number of arguments` means that the command has too few or too many arguments. `ERR CONFIG SET failed` means that a `search-` configuration parameter doesn't accept the value that you gave to [`CONFIG SET`](https://redis.io/docs/latest/commands/config-set). Messages with `Internal error` or `with no context` point to a problem inside Redis Search, not in your command. To fix the other errors, compare your command with the syntax on its command page.

| Error message | Explanation | Returned by |
|---|---|---|
| `ERR CONFIG SET failed (possibly related to argument '<config>') - <config>: value <value> is out of range` | You set `search-max-search-results` or `search-max-aggregate-results` to a negative number other than -1. Use 0 or a positive number of results, or -1 for the largest limit that Redis Search allows. | `CONFIG SET` |
| `ERR CONFIG SET failed (possibly related to argument '<config>') - Invalid default scorer value` | `search-default-scorer` must name a scorer that Redis Search knows, and scorer names are case-sensitive. Use one of `TFIDF`, `TFIDF.DOCNORM`, `BM25`, `BM25STD` (the default), `BM25STD.TANH`, `BM25STD.NORM`, `DISMAX`, `DOCSCORE`, or `HAMMING`. | `CONFIG SET` |
| `ERR CONFIG SET failed (possibly related to argument '<config>') - search-_max-trim-delay-ms (<value>) must be greater than search-_min-trim-delay-ms (<limit>)` | `search-_max-trim-delay-ms` must be larger than the current `search-_min-trim-delay-ms`, the second number in the message. These internal parameters start with an underscore and are normally left at their defaults. To lower both, lower `search-_min-trim-delay-ms` first. | `CONFIG SET` |
| `ERR CONFIG SET failed (possibly related to argument '<config>') - search-_min-trim-delay-ms (<value>) must be less than search-_max-trim-delay-ms (<limit>)` | `search-_min-trim-delay-ms` must be smaller than the current `search-_max-trim-delay-ms`, the second number in the message. These internal parameters start with an underscore and are normally left at their defaults. To raise both, raise `search-_max-trim-delay-ms` first. | `CONFIG SET` |
| `ERR CONFIG SET failed (possibly related to argument '<config>') - search-disk-max-open-files must be -1 (unlimited) or >= 11` | `search-disk-max-open-files`, which applies to Redis Flex, must be -1 for no limit, or 11 or more, because Redis Search keeps about 10 open files for its own use. Set it to -1 or to a value of at least 11. | `CONFIG SET` |
| `ERR Internal error: no cursors stored` | `FT.HYBRID` with `WITHCURSOR`, which is also how shards run it in a cluster, finished without an error but had no cursors to return. This internal consistency check points to a bug in Redis Search. Run the command again. | `FT.HYBRID`, `FT.PROFILE` |
| `ERR Internal error: no request context` | Redis Search ran the query in a background thread but lost track of it before it could send the reply. This is an internal error, not a problem with your command. Run the command again, and if the error repeats, report it to Redis with the command that caused it. | `FT.AGGREGATE`, `FT.CURSOR READ`, `FT.PROFILE`, `FT.SEARCH` |
| `ERR Internal error: no results stored` | The background thread that ran the query finished without storing either results or an error, so Redis Search has nothing to send back. This is an internal error, not a problem with your command. Run the query again, and if the error repeats, report it to Redis. | `FT.AGGREGATE`, `FT.CURSOR READ`, `FT.PROFILE`, `FT.SEARCH` |
| `ERR invalid score` | The score argument of `FT.SUGADD`, after the suggestion string, isn't a number. Give a number such as `1.0`; suggestions with higher scores rank higher in `FT.SUGGET`. | `FT.SUGADD` |
| `ERR timeout with no context` | `FT.SEARCH` in a cluster timed out, and Redis Search couldn't find the request it was waiting for. This is an internal error. Run the query again, and give it more time with `TIMEOUT` if it keeps timing out. | `FT.PROFILE`, `FT.SEARCH` |
| `ERR wrong number of arguments for '<command>' command` | You called the command named in the message with too few or too many arguments. Compare your call with the syntax on the command's page. A common cause is a missing required argument, such as the query of `FT.SEARCH` or the cursor ID of `FT.CURSOR READ`. [How to fix it](https://redis.io/docs/latest/develop/reference/errors/common/err-wrong-number-of-arguments/#how-to-fix-it) | Redis Search commands |


### NOPERM

Your user's access control list (ACL) rules don't allow access to all the keys that the index covers. Redis Search checks that the user can access keys with every prefix of the index. If the index has no `PREFIX`, the user needs access to all keys. To fix it, give the user access to the prefixes of the index, for example with [`ACL SETUSER`](https://redis.io/docs/latest/commands/acl-setuser) and a key pattern such as `~<prefix>*`.

| Error message | Explanation | Returned by |
|---|---|---|
| `NOPERM User does not have the required permissions to query the index` | Your user's access control list (ACL) rules don't allow access to all the keys that the index covers. Give the user access to every `PREFIX` of the index, with a key pattern such as `~doc:*`, or to all keys if it has no `PREFIX`. [How to fix it](https://redis.io/docs/latest/develop/reference/errors/common/noperm/#how-to-fix-it) | Search queries |


### WRONGTYPE

The key that you passed to `FT.SUGADD`, `FT.SUGGET`, `FT.SUGDEL`, or `FT.SUGLEN` holds another type of value, not a suggestion dictionary. To fix it, use a different key for the suggestions, or check the type of the key with [`TYPE`](https://redis.io/docs/latest/commands/type).

| Error message | Explanation | Returned by |
|---|---|---|
| `WRONGTYPE Operation against a key holding the wrong kind of value` | The key that you passed to `FT.SUGADD`, `FT.SUGGET`, `FT.SUGLEN`, or `FT.SUGDEL` exists but isn't a suggestion dictionary; it might be a string or a hash. Use another key for the suggestions, or check the key with `TYPE`. [How to fix it](https://redis.io/docs/latest/develop/reference/errors/common/wrongtype/#how-to-fix-it) | `FT.SUGADD`, `FT.SUGDEL`, `FT.SUGGET`, `FT.SUGLEN` |


## Messages without a code

These messages don't start with an error code. Their first word is an ordinary word, such as `Alias`, `Cursor`, or `DISTANCE`. Clients and [`INFO errorstats`](https://redis.io/docs/latest/commands/info) treat that first word as the code.

| Error message | Explanation | Returned by |
|---|---|---|
| `<command> is not supported in Redis Flex` | You only get this when Redis Search runs on Redis Flex, which doesn't support the command named in the message. Commands without Redis Flex support include `FT.HYBRID`, `FT.ALTER`, `FT.SPELLCHECK`, `FT.TAGVALS`, `FT.MGET`, and `FT.CURSOR`. | `FT.HYBRID`, `FT.PROFILE` |
| `Alias does not exist` | `FT.ALIASDEL` can't find an alias with the name you gave. Check the name for typos. `FT.ALIASLIST` shows the aliases of an index. | `FT.ALIASDEL` |
| `ALTER must be followed by SCHEMA` | In `FT.ALTER`, the index name, and `SKIPINITIALSCAN` if you use it, must be followed by `SCHEMA ADD`. Use `FT.ALTER index [SKIPINITIALSCAN] SCHEMA ADD field type [options]`. | `FT.ALTER` |
| `Bad cursor ID` | The cursor ID that you passed to `FT.CURSOR READ` or `FT.CURSOR DEL` isn't an integer. Pass the cursor ID exactly as `FT.AGGREGATE` with `WITHCURSOR`, or the previous `FT.CURSOR READ`, returned it. | `FT.CURSOR DEL`, `FT.CURSOR READ` |
| `bad distance given, distance must be a natural number between 1 to 4` | The value of `DISTANCE` in `FT.SPELLCHECK`, the maximum Levenshtein distance for suggestions, isn't a whole number from 1 to 4. Use a value such as `DISTANCE 2`. The default is 1. | `FT.SPELLCHECK` |
| `bad format, exclude/include operation was not given` | The word after `TERMS` in `FT.SPELLCHECK` must be `INCLUDE` or `EXCLUDE`. Use `TERMS INCLUDE dict` or `TERMS EXCLUDE dict`, with a dictionary that you created with `FT.DICTADD`. | `FT.SPELLCHECK` |
| `bad reply returned` | You only get this error in a cluster. A shard returned a result for one of the terms of `FT.SPELLCHECK` in a format that the coordinator doesn't expect. Run the command again, and report it to Redis if it continues. | `FT.SPELLCHECK` |
| `` Bad value for COUNT: `<argument>` `` | The value after `COUNT` in `FT.CURSOR READ` isn't an integer, and the message shows what you passed. Give `COUNT` a whole number: the number of results to read in this call. | `FT.CURSOR READ` |
| `Cannot create index on db != 0` | You can only create Redis Search indexes in database 0, but your connection selected another database with `SELECT`. Switch to database 0 with `SELECT 0`, and run `FT.CREATE` again. | `FT.CREATE` |
| `` Cannot perform `<command>`: Cannot block `` | You only get this in a cluster with more than one shard. The command named in the message must wait for the other shards, which it can't do inside `MULTI` and `EXEC`, a Lua script, or a function. Run it outside the transaction or script. | `FT.AGGREGATE`, `FT.ALIASADD`, `FT.ALTER`, `FT.CREATE`, `FT.CURSOR DEL`, `FT.CURSOR READ`, `FT.DROPINDEX`, `FT.HYBRID`, `FT.INFO`, `FT.MGET`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK`, `FT.TAGVALS` |
| `could not analyze term result` | You only get this error in a cluster. The coordinator couldn't read the suggestions that a shard returned for one of the terms of `FT.SPELLCHECK`. Run the command again, and report it to Redis if it continues. | `FT.SPELLCHECK` |
| `Could not distribute command` | You only get this error in a cluster. Redis Search sent the command to the shards but got no reply from any of them, so it can't tell whether the command worked. Check that the shards are running and reachable, and then run the command again. | `FT.ALIASADD`, `FT.ALTER`, `FT.CREATE`, `FT.DROPINDEX`, `FT.SPELLCHECK` |
| `Could not perform query` | You only get this from `FT.TAGVALS` in a cluster. No shard returned a list of values or an error, so the coordinator has nothing to reply with. Check that the shards are running and reachable, and run the command again. | `FT.TAGVALS` |
| `Could not process replies` | You only get this from `FT.MGET` in a cluster. No shard returned a usable list of documents, so the coordinator has nothing to reply with. Check that the shards are running and reachable, and run the command again. | `FT.MGET` |
| `Could not send query to cluster` | You only get this error in a cluster. Redis Search couldn't send the command to the shards, because the connection to at least one shard isn't established, or the cluster topology isn't known yet. Check that all shards are running and reachable, and then run the command again. | `FT.ALIASADD`, `FT.ALTER`, `FT.CREATE`, `FT.DROPINDEX`, `FT.INFO`, `FT.MGET`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK`, `FT.TAGVALS` |
| `Cursor does not exist` | `FT.CURSOR DEL` found no cursor with the ID that you gave. The cursor was already read to the end, deleted, or removed after it was idle longer than its `MAXIDLE` time (300000 milliseconds by default), so there's nothing left to delete. | `FT.CURSOR DEL` |
| `Cursor not found, id: <cursor_id>` | `FT.CURSOR READ` found no idle cursor with the ID in the message. A cursor is removed when you read its last results, when you delete it with `FT.CURSOR DEL`, or when it's idle longer than its `MAXIDLE` time (300000 milliseconds by default). Run `FT.AGGREGATE` with `WITHCURSOR` again to get a new cursor. | `FT.CURSOR READ` |
| `Cursor READ in a context that cannot block (MULTI/EXEC or Lua scripts) is not supported in Redis Flex` | You read a cursor of a Redis Flex index from a place where Redis can't block the client, such as a `MULTI`/`EXEC` transaction or a Lua script. Redis Flex has to wait for data from disk, so read the cursor with a separate command, outside the transaction or script. The cursor stays valid. | `FT.CURSOR READ` |
| `cursor request is not profile, id: <cursor_id>` | A shard was asked for the profile of a cursor that wasn't opened by `FT.PROFILE`. This comes from an internal command that the cluster sends to its shards, not from a command that you normally run. If you see it from `FT.PROFILE`, run the command again, and report it to Redis if it repeats. | `FT.CURSOR PROFILE` |
| `DD is not supported in Redis Flex` | You only get this when Redis Search runs on Redis Flex, where `FT.DROPINDEX` can't delete the documents. Drop the index without `DD`, and delete the keys yourself if you need to. | `FT.DROP`, `FT.DROPINDEX` |
| `Dict does not exist: <dictionary>` | `FT.SPELLCHECK` uses a dictionary in `TERMS INCLUDE` or `TERMS EXCLUDE` that doesn't exist; the message shows its name. Create the dictionary with `FT.DICTADD`, or fix the name. | `FT.SPELLCHECK` |
| `DISTANCE arg is given but no DISTANCE comes after` | `DISTANCE` is the last argument of `FT.SPELLCHECK`, with no value after it. Add the maximum Levenshtein distance, a whole number from 1 to 4, such as `DISTANCE 2`. | `FT.SPELLCHECK` |
| `Error converting string` | An `APPLY` or `FILTER` expression compares a number with text that isn't a number, using `<`, `<=`, `>`, or `>=`, so Redis Search can't order them. Make sure that both sides are numbers. Comparisons with `==` and `!=` don't fail this way. | `FT.ADD`, `FT.AGGREGATE`, `FT.CURSOR READ`, `FT.HYBRID`, `FT.PROFILE`, `FT.SAFEADD` |
| `FT.DROP is not supported in Redis Flex` | You only get this when Redis Search runs on Redis Flex, which doesn't support the deprecated `FT.DROP`. Use `FT.DROPINDEX` instead, which drops the index and keeps the documents. | `FT.DROP`, `FT.DROPINDEX` |
| `FT.PROFILE does not support cursor` | `FT.PROFILE` can't profile a query that uses `WITHCURSOR`. Remove `WITHCURSOR` from the query you profile. | `FT.PROFILE` |
| `Internal error: no AREQ and no preRequestError` | In a cluster, the coordinator finished an `FT.AGGREGATE` or `FT.CURSOR READ` without either a request or an error to reply with. This is an internal error, not a problem with your command. Run the command again, and report it to Redis if it repeats. | `FT.AGGREGATE`, `FT.CURSOR READ`, `FT.PROFILE` |
| `Internal error: no hybrid request and no preRequestError` | In a cluster, the coordinator finished an `FT.HYBRID` without either a request or an error to reply with. This is an internal error, not a problem with your command. Run the command again, and report it to Redis if it repeats. | `FT.HYBRID`, `FT.PROFILE` |
| `Internal error: no request context` | Redis Search ran `FT.HYBRID` in a background thread but lost track of it before it could send the reply. This is an internal error, not a problem with your command. Run the command again, and report it to Redis if it repeats. | `FT.HYBRID`, `FT.PROFILE` |
| `Internal error: no results stored` | The background thread that ran the query finished without storing either results or an error, so Redis Search has nothing to send back. This is an internal error, not a problem with your command. Run the query again, and report it to Redis if it repeats. | `FT.AGGREGATE`, `FT.CURSOR READ`, `FT.HYBRID`, `FT.PROFILE` |
| `Internal error: timeout with no context` | The query reached its timeout, but Redis Search had lost track of the request, so it couldn't send the usual timeout reply. This is an internal error, not a problem with your command. Run the query again, and report it to Redis if it repeats. | `FT.AGGREGATE`, `FT.CURSOR READ`, `FT.HYBRID`, `FT.PROFILE` |
| `Invalid payload: <reason>` | `PAYLOAD` is the last argument of `FT.SUGADD`, with no value after it. Add the payload string after `PAYLOAD`, or remove `PAYLOAD`. | `FT.SUGADD` |
| `Invalid query` | The prefix that you passed to `FT.SUGGET` is longer than 100 characters, the most that it can complete. Use a shorter prefix. | `FT.SUGGET` |
| `Invalid query length` | The prefix that you passed to `FT.SUGGET` is longer than 200 bytes. Use a shorter prefix: `FT.SUGGET` completes prefixes of up to 100 characters. | `FT.SUGGET` |
| `Invalid UTF-8` | A document's value in a `SORTABLE` `TEXT`, `TAG`, or `GEO` field isn't valid Unicode text, so Redis Search can't normalize it for sorting and doesn't index the document. `FT.INFO` reports it. Store valid text, or declare the field `SORTABLE UNF`. | `FT.ADD`, `FT.SAFEADD` |
| `Maximum group IDs per term limit reached` | A term in `FT.SYNUPDATE` would belong to more than 4,096 synonym groups, the limit per term. Use fewer groups for that term. `FT.SYNUPDATE` can't remove terms from groups, so undoing groups means creating the index again. | `FT.SYNUPDATE` |
| `Maximum synonym terms limit reached` | `FT.SYNUPDATE` would take the synonyms of the index over 1,000,000 distinct terms, the limit per index. Add fewer terms. `FT.SYNUPDATE` can't remove terms, so freeing space means creating the index again. | `FT.SYNUPDATE` |
| `Module Disabled in Open Source Redis` | Redis Search replaced the command with a placeholder that always fails, because it runs on Redis Software with a cluster configuration it doesn't expect. Despite its wording, this is a deployment problem, so contact your administrator or Redis support. | Redis Search commands |
| `` No `SEARCH`, `AGGREGATE`, or `HYBRID` provided `` | In `FT.PROFILE`, the argument after the index name must be `SEARCH`, `AGGREGATE`, or `HYBRID`, the kind of query to profile. Use `FT.PROFILE index SEARCH [LIMITED] QUERY query`, for example. | `FT.PROFILE` |
| `No fields provided` | `FT.ALTER ... SCHEMA ADD` has no field after `ADD`. Redis rejects such a short command with a wrong number of arguments error first, so you'll see that instead. Add a field name and type after `ADD`. | `FT.ALTER` |
| `No longer supported, use FT.SYNUPDATE` | `FT.SYNADD` was removed and always returns this error. Use `FT.SYNUPDATE index group term [term ...]` instead, where you choose the name of the synonym group yourself. | `FT.SYNADD` |
| `Payload too large` | The payload of `FT.SUGADD` is too large to store, at about 4 gigabytes or more. Store a much smaller payload, such as the name of a key that holds the data. | `FT.SUGADD` |
| `TERM arg is given but no TERM params comes after` | `TERMS` in `FT.SPELLCHECK` must be followed by `INCLUDE` or `EXCLUDE` and a dictionary name, but the command ends too early. Use `TERMS INCLUDE dict` or `TERMS EXCLUDE dict`, with a dictionary that you created with `FT.DICTADD`. | `FT.SPELLCHECK` |
| `term exists in index` | This isn't a failure. With `FULLSCOREINFO`, an option that the cluster coordinator adds, `FT.SPELLCHECK` returns this text for a query term that's already in the index. Clients that use protocol version 3 see it as an error entry inside the reply. | `FT.SPELLCHECK` |
| `The index was dropped while the cursor was idle` | The index was dropped while an `FT.PROFILE` aggregation in a cluster was still collecting results from the shards, so the profile can't be completed. Create the index again if you need it, and then run `FT.PROFILE` again. | `FT.CURSOR PROFILE` |
| `The QUERY keyword is expected` | In `FT.PROFILE`, `QUERY` must follow `SEARCH`, `AGGREGATE`, or `HYBRID`, or `LIMITED` if you use it, and the query comes after `QUERY`. Use `FT.PROFILE index SEARCH [LIMITED] QUERY query`, for example. | `FT.PROFILE` |
| `Timeout calling command` | In a cluster, the coordinator gave up waiting for the shards to answer a command that it sent to all of them. Check that the shards are running and reachable, and then run the command again. | `FT.ALIASADD`, `FT.ALTER`, `FT.CREATE`, `FT.DROPINDEX`, `FT.INFO`, `FT.MGET`, `FT.PROFILE`, `FT.SEARCH`, `FT.SPELLCHECK`, `FT.TAGVALS` |
| `Unknown action passed to ALTER SCHEMA` | `FT.ALTER` can only add fields, so `SCHEMA` must be followed by `ADD`. To remove or change a field, drop the index with `FT.DROPINDEX`, without `DD` so the documents stay, and create it again with the new schema. | `FT.ALTER` |
| `` Unknown argument `<argument>` `` | The command got an argument that it doesn't recognize, shown in the message. After the cursor ID, `FT.CURSOR READ` accepts only `COUNT` and a number. After the score, `FT.SUGADD` accepts only `INCR` and `PAYLOAD` with a value. | `FT.CURSOR READ`, `FT.SUGADD` |