Redis Query Engine

https://redis.io/docs/latest/develop/ai/search-and-query/
Admin
The Redis Query Engine provides enhanced search and query capabilities for Redis data, including a...
Tokens:189,330
Snippets:1,278
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Full Range Query Setup Example

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/range

Complete example demonstrating index creation, JSON object population, and range query execution.

```java
import io.lettuce.core.*;
import io.lettuce.core.api.async.RedisAsyncCommands;

import io.lettuce.core.search.arguments.*;
import io.lettuce.core.search.SearchReply;

import io.lettuce.core.json.JsonPath;
import io.lettuce.core.json.JsonParser;
import io.lettuce.core.json.JsonObject;
import io.lettuce.core.api.StatefulRedisConnection;

import java.util.*;
import java.util.concurrent.CompletableFuture;

public class QueryRangeExample {

    public void run() {
        RedisClient redisClient = RedisClient.create("redis://localhost:6379");

        try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
            RedisAsyncCommands<String, String> asyncCommands = connection.async();

            List<FieldArgs<String>> bicycleSchema = Arrays.asList(
                    TextFieldArgs.<String> builder().name("$.brand").as("brand").build(),
                    TextFieldArgs.<String> builder().name("$.model").as("model").build(),
                    TextFieldArgs.<String> builder().name("$.description").as("description").build(),
                    NumericFieldArgs.<String> builder().name("$.price").as("price").build(),
                    TagFieldArgs.<String> builder().name("$.condition").as("condition").build());

            CreateArgs<String, String> bicycleCreateArgs = CreateArgs.<String, String> builder().on(CreateArgs.TargetType.JSON)
                    .withPrefix("bicycle:").build();

            asyncCommands.ftCreate("idx:bicycle", bicycleCreateArgs, bicycleSchema).toCompletableFuture().join();

            JsonParser parser = asyncCommands.getJsonParser();

            List<JsonObject> bicycleJsons = Arrays.asList(parser.createJsonObject()
                    .put("brand", parser.createJsonValue("\"Velorim\"")).put("model", parser.createJsonValue("\"Jigger\""))
                    .put("description", parser
                            .createJsonValue("\"Small and powerful, the Jigger is the best ride for the smallest of tikes! "
                                    + "This is the tiniest kids’ pedal bike on the market available without a coaster brake, the Jigger "
                                    + "is the vehicle of choice for the rare tenacious little rider raring to go.\""))
                    .put("price", parser.createJsonValue("270")).put("condition", parser.createJsonValue("\"new\"")),
                    parser.createJsonObject().put("brand", parser.createJsonValue("\"Bicyk\""))
                            .put("model", parser.createJsonValue("\"Hillcraft\""))
                            .put("description",
                                    parser.createJsonValue("\"Kids want to ride with as little weight as possible. Especially "
                                            + "on an incline! They may be at the age when a 27.5'' wheel bike is just too clumsy coming "
                                            + "off a 24'' bike. The Hillcraft 26 is just the solution they need!\""))
                            .put("price", parser.createJsonValue("1200")).put("condition", parser.createJsonValue("\"used\"")),
                    parser.createJsonObject().put("brand", parser.createJsonValue("\"Nord\""))
                            .put("model", parser.createJsonValue("\"Chook air 5\""))
                            .put("description",
                                    parser.createJsonValue("\"The Chook Air 5  gives kids aged six years and older a durable "
                                            + "and uberlight mountain bike for their first experience on tracks and easy cruising through "
                                            + "forests and fields. The lower  top tube makes it easy to mount and dismount in any "
                                            + "situation, giving your kids greater safety on the trails.\""))
                            .put("price", parser.createJsonValue("815")).put("condition", parser.createJsonValue("\"used\"")),
                    parser.createJsonObject().put("brand", parser.createJsonValue("\"Eva\""))
                            .put("model", parser.createJsonValue("\"Eva 291\""))
                            .put("description",
                                    parser.createJsonValue("\"The sister company to Nord, Eva launched in 2005 as the first "
```

--------------------------------

### Full Reactive Setup Example

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/exact-match

Complete setup for creating an index and inserting JSON data using reactive Redis commands.

```java
import io.lettuce.core.*;
import io.lettuce.core.api.reactive.RedisReactiveCommands;

import io.lettuce.core.search.arguments.*;
import io.lettuce.core.search.SearchReply;

import io.lettuce.core.json.JsonPath;
import io.lettuce.core.json.JsonParser;
import io.lettuce.core.json.JsonObject;
import io.lettuce.core.api.StatefulRedisConnection;

import java.util.*;
import reactor.core.publisher.Mono;

public class QueryEmExample {

    public void run() {
        RedisClient redisClient = RedisClient.create("redis://localhost:6379");

        try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
            RedisReactiveCommands<String, String> reactiveCommands = connection.reactive();

            List<FieldArgs<String>> bicycleSchema = Arrays.asList(
                    TextFieldArgs.<String> builder().name("$.brand").as("brand").build(),
                    TextFieldArgs.<String> builder().name("$.model").as("model").build(),
                    TextFieldArgs.<String> builder().name("$.description").as("description").build(),
                    NumericFieldArgs.<String> builder().name("$.price").as("price").build(),
                    TagFieldArgs.<String> builder().name("$.condition").as("condition").build());

            CreateArgs<String, String> bicycleCreateArgs = CreateArgs.<String, String> builder().on(CreateArgs.TargetType.JSON)
                    .withPrefix("bicycle:").build();

            reactiveCommands.ftCreate("idx:bicycle", bicycleCreateArgs, bicycleSchema).block();

            JsonParser parser = reactiveCommands.getJsonParser();

            List<JsonObject> bicycleJsons = Arrays.asList(parser.createJsonObject()
                    .put("brand", parser.createJsonValue("\"Velorim\"")).put("model", parser.createJsonValue("\"Jigger\""))
                    .put("description", parser
                            .createJsonValue("\"Small and powerful, the Jigger is the best ride for the smallest of tikes! "
                                    + "This is the tiniest kids’ pedal bike on the market available without a coaster brake, the Jigger "
                                    + "is the vehicle of choice for the rare tenacious little rider raring to go.\""))
                    .put("price", parser.createJsonValue("270")).put("condition", parser.createJsonValue("\"new\"")),
                    parser.createJsonObject().put("brand", parser.createJsonValue("\"Bicyk\""))
                            .put("model", parser.createJsonValue("\"Hillcraft\""))
                            .put("description",
                                    parser.createJsonValue("\"Kids want to ride with as little weight as possible. Especially "
```

--------------------------------

### Setup and Index Creation for Numeric Fields

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/exact-match

Full example showing the connection setup, index creation with schema definitions, and data ingestion for numeric field querying.

```csharp
using NRedisStack.RedisStackCommands;
using NRedisStack.Search;
using NRedisStack.Search.Literals.Enums;
using NRedisStack.Tests;
using StackExchange.Redis;



public class QueryEmExample
{
    public void Run()
    {
        var muxer = ConnectionMultiplexer.Connect("localhost:6379");
        var db = muxer.GetDatabase();

        FTCreateParams idxParams = new FTCreateParams()
            .AddPrefix("bicycle:")
            .On(IndexDataType.JSON);

        Schema bikeSchema = new Schema()
            .AddTextField(new FieldName("$.description", "description"))
            .AddNumericField(new FieldName("$.price", "price"))
            .AddTagField(new FieldName("$.condition", "condition"));

        db.FT().Create("idx:bicycle", idxParams, bikeSchema);


        var bicycles = new object[]
            {
                new
                {
                    brand = "Velorim",
                    model = "Jigger",
                    price = 270,
                    description = "Small and powerful, the Jigger is the best ride " +
                                    "for the smallest of tikes! This is the tiniest " +
                                    "kids’ pedal bike on the market available without" +
                                    " a coaster brake, the Jigger is the vehicle of " +
                                    "choice for the rare tenacious little rider " +
                                    "raring to go.",
                    condition = "used"
                },
                new
                {
                    brand = "Bicyk",
                    model = "Hillcraft",
                    price = 1200,
                    description = "Kids want to ride with as little weight as possible." +
                        " Especially on an incline! They may be at the age " +
                        "when a 27.5 inch wheel bike is just too clumsy coming " +
                        "off a 24 inch bike. The Hillcraft 26 is just the solution" +
                        " they need!",
                    condition = "used",
                },
                new
                {
                    brand = "Nord",
                    model = "Chook air 5",
                    price = 815,
                    description = "The Chook Air 5  gives kids aged six years and older " +
                        "a durable and uberlight mountain bike for their first" +
                        " experience on tracks and easy cruising through forests" +
                        " and fields. The lower  top tube makes it easy to mount" +
                        " and dismount in any situation, giving your kids greater" +
                        " safety on the trails.",
                    condition = "used",
                },
                new
                {
                    brand = "Eva",
                    model = "Eva 291",
                    price = 3400,
                    description = "The sister company to Nord, Eva launched in 2005 as the" +
                        " first and only women-dedicated bicycle brand. Designed" +
                        " by women for women, allEva bikes are optimized for the" +
                        " feminine physique using analytics from a body metrics" +
                        " database. If you like 29ers, try the Eva 291. It’s a " +
                        "brand new bike for 2022.. This full-suspension, " +
                        "cross-country ride has been designed for velocity. The" +
                        " 291 has 100mm of front and rear travel, a superlight " +
                        "aluminum frame and fast-rolling 29-inch wheels. Yippee!",
                    condition = "used",
                },
                new
                {
                    brand = "Noka Bikes",
                    model = "Kahuna",
                    price = 3200,
```

--------------------------------

### Installing prerequisites using a setup script

Source: https://redis.io/docs/latest/develop/ai/search-and-query/deprecated/development

To build and test RediSearch, install prerequisites using a setup script. Navigate to the 'install' directory and run the script with 'sudo'.

```bash
cd ./install
./install_script.sh sudo
./install_boost.sh 1.83.0

```

--------------------------------

### Full Geospatial Indexing and Querying Example

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/geo-spatial

Complete setup including index creation, data loading, and various geospatial queries using Python.

```python
import json
import sys
import redis
from redis.commands.json.path import Path
from redis.commands.search.field import GeoField, GeoShapeField
from redis.commands.search.index_definition import IndexDefinition, IndexType
from redis.commands.search.query import Query

r = redis.Redis(decode_responses=True)

# create index
schema = (
    GeoField("$.store_location", as_name="store_location"),
    GeoShapeField("$.pickup_zone", coord_system=GeoShapeField.FLAT, as_name="pickup_zone")
)

index = r.ft("idx:bicycle")
index.create_index(
    schema,
    definition=IndexDefinition(prefix=["bicycle:"], index_type=IndexType.JSON),
)

# load data
with open("data/query_em.json") as f:
    bicycles = json.load(f)

pipeline = r.pipeline(transaction=False)
for bid, bicycle in enumerate(bicycles):
    pipeline.json().set(f'bicycle:{bid}', Path.root_path(), bicycle)
pipeline.execute()

params_dict = {"lon": -0.1778, "lat": 51.5524, "radius": 20, "units": "mi"}
q = Query("@store_location:[$lon $lat $radius $units]").dialect(2)
res = index.search(q, query_params=params_dict)
print(res)
# >>> Result{1 total, docs: [Document {'id': 'bicycle:5', ...

params_dict = {"bike": "POINT(-0.1278 51.5074)"}
q = Query("@pickup_zone:[CONTAINS $bike]").dialect(3)
res = index.search(q, query_params=params_dict)
print(res.total) # >>> 1

params_dict = {"europe": "POLYGON((-25 35, 40 35, 40 70, -25 70, -25 35))"}
q = Query("@pickup_zone:[WITHIN $europe]").dialect(3)
res = index.search(q, query_params=params_dict)
print(res.total) # >>> 5
```

--------------------------------

### Example workflow: Get suggestions

Source: https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/autocomplete

Step 1 of the example workflow: Use FT.SUGGET to suggest query completions as users type.

```redis
FT.SUGGET autocomplete "hel"

```

--------------------------------

### Full Python implementation example

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/full-text

A complete example showing index creation, data loading, and various search queries including wildcards and fuzzy matching.

```Python
import json
import sys
import redis
from redis.commands.json.path import Path
from redis.commands.search.field import TextField, NumericField, TagField
from redis.commands.search.index_definition import IndexDefinition, IndexType
from redis.commands.search.query import NumericFilter, Query

r = redis.Redis(decode_responses=True)

# create index
schema = (
    TextField("$.brand", as_name="brand"),
    TextField("$.model", as_name="model"),
    TextField("$.description", as_name="description"),
)

index = r.ft("idx:bicycle")
index.create_index(
    schema,
    definition=IndexDefinition(prefix=["bicycle:"], index_type=IndexType.JSON),
)

# load data
with open("data/query_em.json") as f:
    bicycles = json.load(f)

pipeline = r.pipeline(transaction=False)
for bid, bicycle in enumerate(bicycles):
    pipeline.json().set(f'bicycle:{bid}', Path.root_path(), bicycle)
pipeline.execute()

res = index.search(Query("@description: kids"))
print(res.total)
# >>> 2

res = index.search(Query("@model: ka*"))
print(res.total)
# >>> 1

res = index.search(Query("@brand: *bikes"))
print(res.total)
# >>> 2

res = index.search(Query("%optamized%"))
print(res)
# >>> Result{1 total, docs: [Document {'id': 'bicycle:3', 'payload': None, 'json': '{"pickup_zone":"POLYGON((-80.2433 25.8067, -80.1333 25.8067, -80.1333 25.6967, -80.2433 25.6967, -80.2433 25.8067))","store_location":"-80.1918,25.7617","brand":"Eva","model":"Eva 291","price":3400,"description":"The sister company to Nord, Eva launched in 2005 as the first and only women-dedicated bicycle brand. Designed by women for women, allEva bikes are optimized for the feminine physique using analytics from a body metrics database. If you like 29ers, try the Eva 291. It’s a brand new bike for 2022.. This full-suspension, cross-country ride has been designed for velocity. The 291 has 100mm of front and rear travel, a superlight aluminum frame and fast-rolling 29-inch wheels. Yippee!","condition":"used"}'}]}

res = index.search(Query("%%optamised%%"))
print(res)
# >>> Result{1 total, docs: [Document {'id': 'bicycle:3', 'payload': None, 'json': '{"pickup_zone":"POLYGON((-80.2433 25.8067, -80.1333 25.8067, -80.1333 25.6967, -80.2433 25.6967, -80.2433 25.8067))","store_location":"-80.1918,25.7617","brand":"Eva","model":"Eva 291","price":3400,"description":"The sister company to Nord, Eva launched in 2005 as the first and only women-dedicated bicycle brand. Designed by women for women, allEva bikes are optimized for the feminine physique using analytics from a body metrics database. If you like 29ers, try the Eva 291. It’s a brand new bike for 2022.. This full-suspension, cross-country ride has been designed for velocity. The 291 has 100mm of front and rear travel, a superlight aluminum frame and fast-rolling 29-inch wheels. Yippee!","condition":"used"}'}]}
```

--------------------------------

### Full Python Implementation Example

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/exact-match

A complete example showing index creation, data loading, and various query types including tag and text fields.

```python
import json
import redis
from redis.commands.json.path import Path
from redis.commands.search.field import TextField, NumericField, TagField
from redis.commands.search.index_definition import IndexDefinition, IndexType
from redis.commands.search.query import NumericFilter, Query

r = redis.Redis(decode_responses=True)

# create index
schema = (
    TextField("$.description", as_name="description"),
    NumericField("$.price", as_name="price"),
    TagField("$.condition", as_name="condition"),
)

index = r.ft("idx:bicycle")
index.create_index(
    schema,
    definition=IndexDefinition(prefix=["bicycle:"], index_type=IndexType.JSON),
)

# load data
with open("data/query_em.json") as f:
    bicycles = json.load(f)

pipeline = r.pipeline(transaction=False)
for bid, bicycle in enumerate(bicycles):
    pipeline.json().set(f'bicycle:{bid}', Path.root_path(), bicycle)
pipeline.execute()

res = index.search(Query("@price:[270 270]"))
print(res.total)
# >>> 1

try:
    res = index.search(Query("@price:[270]")) # not yet supported in redis-py
    print(res.total)
    # >>> 1
    assert res.total == 1
except Exception:
    print("'@price:[270]' syntax not yet supported.")

try:
    res = index.search(Query("@price==270")) # not yet supported in redis-py
    print(res.total)
    # >>> 1
    assert res.total == 1
except Exception:
    print("'@price==270' syntax not yet supported.")

query = Query("*").add_filter(NumericFilter("price", 270, 270))
res = index.search(query)
print(res.total)
# >>> 1

res = index.search(Query("@condition:{new}"))
print(res.total)
# >>> 5

schema = (
    TagField("$.email", as_name="email")
)

idx_email = r.ft("idx:email")
idx_email.create_index(
    schema,
    definition=IndexDefinition(prefix=["key:"], index_type=IndexType.JSON),
)
r.json().set('key:1', Path.root_path(), '{"email": "test@redis.com"}')

try:
    res = idx_email.search(Query("test@redis.com").dialect(2))
    print(res)
except Exception:
    print("'test@redis.com' syntax not yet supported.")

res = index.search(Query("@description:\"rough terrain\""))
print(res.total)
# >>> 1 (Result{1 total, docs: [Document {'id': 'bicycle:8'...)
```

--------------------------------

### Example Init Function

Source: https://redis.io/docs/latest/develop/ai/search-and-query/administration/extensions

An example C function demonstrating how to register a scoring function and a query expander.

```c
#include <redisearch.h> //must be in the include path

int RS_ExtensionInit(RSExtensionCtx *ctx) {

  /* Register  a scoring function with an alias my_scorer and no special private data and free function */
  if (ctx->RegisterScoringFunction("my_scorer", MyCustomScorer, NULL, NULL) == REDISEARCH_ERR) {
    return REDISEARCH_ERR;
  }

  /* Register a query expander  */
  if (ctx->RegisterQueryExpander("my_expander", MyExpander, NULL, NULL) ==
      REDISEARCH_ERR) {
    return REDISEARCH_ERR;
  }

  return REDISEARCH_OK;
}

```

--------------------------------

### Practical Example: Travel Database

Source: https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/tags

A practical example demonstrating tag queries on a travel database, showing both OR and AND logic.

```redis
FT.CREATE travelers ON HASH PREFIX 1 traveler: SCHEMA
    name TEXT
    cities TAG

HSET traveler:1 name "John Doe" cities "New York, Barcelona, San Francisco"
HSET traveler:2 name "Jane Smith" cities "New York, Los Angeles, Tokyo"

# Find travelers who visited any of these cities:
FT.SEARCH travelers "@cities:{ New York | Los Angeles | Barcelona }"
# Returns: Both John and Jane

# Find travelers who visited all of these cities:
FT.SEARCH travelers "@cities:{ New York } @cities:{ Barcelona }"
# Returns: Only John (has both New York and Barcelona)
```

--------------------------------

### Vector Field Creation Example

Source: https://redis.io/docs/latest/develop/ai/search-and-query/indexing/field-and-type-options

Example of creating a vector index with specific parameters.

```redis-cli
FT.CREATE my_idx SCHEMA vec_field VECTOR FLAT 6 TYPE FLOAT32 DIM 128 DISTANCE_METRIC L2

```

--------------------------------

### Example of creating a synonym group and searching

Source: https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/synonyms

This example demonstrates how to create a synonym group, insert documents, and then search for a term, retrieving documents containing its synonyms.

```redis-cli
# Create an index
> FT.CREATE idx schema t text

# Create a synonym group 
> FT.SYNUPDATE idx group1 hello world

# Insert documents
> HSET foo t hello
(integer) 1
> HSET bar t world
(integer) 1

# Search
> FT.SEARCH idx hello
1) (integer) 2
2) "foo"
3) 1) "t"
   2) "hello"
4) "bar"
5) 1) "t"
   2) "world"
```

--------------------------------

### Example of searching and sorting

Source: https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/sorting

Examples of creating an index, adding data, and performing searches with sorting.

```redis
> FT.CREATE users ON HASH PREFIX 1 "user" SCHEMA first_name TEXT SORTABLE last_name TEXT age NUMERIC SORTABLE

# Add some users
> HSET user1 first_name "alice" last_name "jones" age 35
> HSET user2 first_name "bob" last_name "jones" age 36

# Searching while sorting

# Searching by last name and sorting by first name
> FT.SEARCH users "@last_name:jones" SORTBY first_name DESC

# Searching by both first and last name, and sorting by age
> FT.SEARCH users "jones" SORTBY age ASC

```

--------------------------------

### Example: Create an Inventory Item Index

Source: https://redis.io/docs/latest/develop/ai/search-and-query/indexing

An example command to create an index for inventory items, including text, numeric, and vector fields.

```redis-cli
127.0.0.1:6379> FT.CREATE itemIdx ON JSON PREFIX 1 item: SCHEMA $.name AS name TEXT $.description as description TEXT $.price AS price NUMERIC $.embedding AS embedding VECTOR FLAT 6 DIM 4 DISTANCE_METRIC L2 TYPE FLOAT32
```

--------------------------------

### Go Aggregation Example

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/aggregation

Performs an aggregation query using the Go Redis client.

```go
	res2, err := rdb.FTAggregateWithArgs(ctx,
		"idx:bicycle", "*",
		&redis.FTAggregateOptions{
			Steps: []redis.FTAggregateStep{
				{Load: &redis.FTAggregateLoad{Field: "price"}},
				{Apply: &redis.FTAggregateApply{
					Field: "@price<1000",
					As:    "price_category",
				}},
				{GroupBy: &redis.FTAggregateGroupBy{
					Fields: []interface{}{"@condition"},
					Reduce: []redis.FTAggregateReducer{
						{
							Reducer: redis.SearchSum,
							Args:    []interface{}{"@price_category"},
							As:      "num_affordable",
						},
					},
				}},
			},
		},
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(len(res2.Rows)) // >>> 3

	sort.Slice(res2.Rows, func(i, j int) bool {
		return res2.Rows[i].Fields["condition"].(string) <
			res2.Rows[j].Fields["condition"].(string)
	})

	for _, row := range res2.Rows {
		fmt.Printf(
			"condition=%v, num_affordable=%v\n",
			row.Fields["condition"],
			row.Fields["num_affordable"],
		)
	}
	// >>> condition=new, num_affordable=3
	// >>> condition=refurbished, num_affordable=1
	// >>> condition=used, num_affordable=1
```

--------------------------------

### Full Setup for Query Aggregation

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/aggregation

Demonstrates the full lifecycle including index creation, schema definition, and JSON data loading using the Lettuce client.

```java
import io.lettuce.core.*;
import io.lettuce.core.api.async.RedisAsyncCommands;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.json.JsonPath;
import io.lettuce.core.json.JsonParser;
import io.lettuce.core.json.JsonObject;
import io.lettuce.core.search.arguments.AggregateArgs;
import io.lettuce.core.search.arguments.AggregateArgs.GroupBy;
import io.lettuce.core.search.arguments.AggregateArgs.Reducer;
import io.lettuce.core.search.AggregationReply;

import io.lettuce.core.search.arguments.CreateArgs;
import io.lettuce.core.search.arguments.FieldArgs;
import io.lettuce.core.search.arguments.NumericFieldArgs;
import io.lettuce.core.search.arguments.TagFieldArgs;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;

public class QueryAggregationExample {

    public void run() {
        RedisClient redisClient = RedisClient.create("redis://localhost:6379");

        try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
            RedisAsyncCommands<String, String> asyncCommands = connection.async();
            JsonParser parser = asyncCommands.getJsonParser();


            // create index
            List<FieldArgs<String>> schema = Arrays.asList(
                    TagFieldArgs.<String> builder().name("$.condition").as("condition").build(),
                    NumericFieldArgs.<String> builder().name("$.price").as("price").build());

            CreateArgs<String, String> createArgs = CreateArgs.<String, String> builder().withPrefix("bicycle:")
                    .on(CreateArgs.TargetType.JSON).build();

            // load data using JsonParser
            List<JsonObject> bicycleJsons = Arrays.asList(parser.createJsonObject().put("pickup_zone", parser.createJsonValue(
                    "\"POLYGON((-74.0610 40.7578, -73.9510 40.7578, -73.9510 40.6678, -74.0610 40.6678, -74.0610 40.7578))\""))
                    .put("store_location", parser.createJsonValue("\"-74.0060,40.7128\""))
                    .put("brand", parser.createJsonValue("\"Velorim\"")).put("model", parser.createJsonValue("\"Jigger\""))
                    .put("price", parser.createJsonValue("270"))
                    .put("description", parser
                            .createJsonValue("\"Small and powerful, the Jigger is the best ride for the smallest of tikes! "
                                    + "This is the tiniest kids' pedal bike on the market available without a coaster brake, the Jigger "
                                    + "is the vehicle of choice for the rare tenacious little rider raring to go.\""))
                    .put("condition", parser.createJsonValue("\"new\"")),
                    parser.createJsonObject().put("pickup_zone", parser.createJsonValue(
                            "\"POLYGON((-118.2887 34.0972, -118.1987 34.0972, -118.1987 33.9872, -118.2887 33.9872, -118.2887 34.0972))\""))
                            .put("store_location", parser.createJsonValue("\"-118.2437,34.0522\""))
                            .put("brand", parser.createJsonValue("\"Bicyk\""))
                            .put("model", parser.createJsonValue("\"Hillcraft\"")).put("price", parser.createJsonValue("1200"))
                            .put("description",
                                    parser.createJsonValue("\"Kids want to ride with as little weight as possible. Especially "
                                            + "on an incline! They may be at the age when a 27.5'' wheel bike is just too clumsy coming "
```

--------------------------------

### Multiple TAG fields setup

Source: https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/tags

Example of creating a Redis index with multiple single-value TAG fields and setting a JSON document.

```redis
FT.CREATE products ON JSON PREFIX 1 product: SCHEMA
    $.color AS color TAG
    $.brand AS brand TAG
    $.type AS type TAG

JSON.SET product:1 $ '{"color": "blue", "brand": "ASUS", "type": "laptop"}'

# Query specific fields
FT.SEARCH products '@color:{blue} @brand:{ASUS}'
```

--------------------------------

### Setup Index and Data

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/aggregation

Initializes a Redis connection, defines a schema for JSON documents, and creates an index for bicycle data.

```csharp
using NRedisStack.RedisStackCommands;
using NRedisStack.Search;
using NRedisStack.Search.Aggregation;
using NRedisStack.Search.Literals.Enums;
using NRedisStack.Tests;
using StackExchange.Redis;



public class QueryAggExample
{
    public void Run()
    {
        var muxer = ConnectionMultiplexer.Connect("localhost:6379");
        var db = muxer.GetDatabase();

        Schema bikeSchema = new Schema()
            .AddTagField(new FieldName("$.condition", "condition"))
            .AddNumericField(new FieldName("$.price", "price"));

        FTCreateParams bikeParams = new FTCreateParams()
            .AddPrefix("bicycle:")
            .On(IndexDataType.JSON);

        db.FT().Create("idx:bicycle", bikeParams, bikeSchema);

        var bicycles = new object[] {
            new
            {
                pickup_zone = "POLYGON((-74.0610 40.7578, -73.9510 40.7578, -73.9510 40.6678, -74.0610 40.6678, -74.0610 40.7578))",
                store_location = "-74.0060,40.7128",
                brand = "Velorim",
                model = "Jigger",
                price = 270,
                description = "Small and powerful, the Jigger is the best ride for the smallest of tikes! This is the tiniest kids’ pedal bike on the market available without a coaster brake, the Jigger is the vehicle of choice for the rare tenacious little rider raring to go.",
                condition = "new"
            },
            new
            {
                pickup_zone = "POLYGON((-118.2887 34.0972, -118.1987 34.0972, -118.1987 33.9872, -118.2887 33.9872, -118.2887 34.0972))",
                store_location = "-118.2437,34.0522",
                brand = "Bicyk",
                model = "Hillcraft",
                price = 1200,
                description = "Kids want to ride with as little weight as possible. Especially on an incline! They may be at the age when a 27.5\" wheel bike is just too clumsy coming off a 24\" bike. The Hillcraft 26 is just the solution they need!",
                condition = "used"
            },
            new
            {
                pickup_zone = "POLYGON((-87.6848 41.9331, -87.5748 41.9331, -87.5748 41.8231, -87.6848 41.8231, -87.6848 41.9331))",
                store_location = "-87.6298,41.8781",
                brand = "Nord",
                model = "Chook air 5",
                price = 815,
                description = "The Chook Air 5  gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. The lower  top tube makes it easy to mount and dismount in any situation, giving your kids greater safety on the trails.",
                condition = "used"
            },
            new
            {
                pickup_zone = "POLYGON((-80.2433 25.8067, -80.1333 25.8067, -80.1333 25.6967, -80.2433 25.6967, -80.2433 25.8067))",
                store_location = "-80.1918,25.7617",
                brand = "Eva",
                model = "Eva 291",
                price = 3400,
                description = "The sister company to Nord, Eva launched in 2005 as the first and only women-dedicated bicycle brand. Designed by women for women, allEva bikes are optimized for the feminine physique using analytics from a body metrics database. If you like 29ers, try the Eva 291. It’s a brand new bike for 2022.. This full-suspension, cross-country ride has been designed for velocity. The 291 has 100mm of front and rear travel, a superlight aluminum frame and fast-rolling 29-inch wheels. Yippee!",
                condition = "used"
            },
            new
            {
                pickup_zone = "POLYGON((-122.4644 37.8199, -122.3544 37.8199, -122.3544 37.7099, -122.4644 37.7099, -122.4644 37.8199))",
                store_location = "-122.4194,37.7749",
                brand = "Noka Bikes",
                model = "Kahuna",
                price = 3200,
```

--------------------------------

### Single multi-value TAG field setup

Source: https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/tags

Example of creating a Redis index with a single multi-value TAG field and setting a JSON document.

```redis
FT.CREATE products ON JSON PREFIX 1 product: SCHEMA
    $.tags[*] AS tags TAG

JSON.SET product:1 $ '{"tags": ["color:blue", "brand:ASUS", "type:laptop"]}'

# Query with prefixed values
FT.SEARCH products '@tags:{color:blue} @tags:{brand:ASUS}'
```

--------------------------------

### Committing and re-invoking a Docker container

Source: https://redis.io/docs/latest/develop/ai/search-and-query/deprecated/development

After working in a Docker container, you can commit its state to an image and re-invoke it later. This example commits the current container, stops it, and then starts a new one from the committed image.

```bash
docker commit $search redisearch1
docker stop $search
search=$(docker run -d -it -v $PWD:/build rediseatch1 bash)
docker exec -it $search bash

```

--------------------------------

### Java-Async Quick-Start for Tag Fields

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/exact-match

Demonstrates creating a JSON index with a Tag field, setting a JSON document, and searching for an exact email match.

```java
            List<FieldArgs<String>> emailSchema = Arrays
                    .asList(TagFieldArgs.<String> builder().name("$.email").as("email").build());

            CreateArgs<String, String> emailCreateArgs = CreateArgs.<String, String> builder().on(CreateArgs.TargetType.JSON)
                    .withPrefix("key:").build();

            Mono<Void> emailResults = reactiveCommands.ftCreate("idx:email", emailCreateArgs, emailSchema).doOnNext(res -> {
                System.out.println(res); // >>> OK
            }).flatMap(res -> reactiveCommands.jsonSet("key:1", JsonPath.ROOT_PATH,
                    parser.createJsonObject().put("email", parser.createJsonValue("\"test@redis.com\"")))).doOnNext(res -> {
                        System.out.println(res); // >>> OK
                    }).flatMap(res -> reactiveCommands.ftSearch("idx:email", "@email:{test\\@redis\\.com}")).doOnNext(res -> {
                        System.out.println(res.getResults().size()); // >>> 1
                        System.out.println(res.getResults().get(0).getId());
                        // >>> key:1
                    }).then();
```

--------------------------------

### GEOSHAPE primitives example

Source: https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/geo

Examples of POINT and POLYGON primitives for GEOSHAPE fields.

```text
POINT (2 2)
POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))
POLYGON ((2 2.5, 2 3.5, 3.5 3.5, 3.5 2.5, 2 2.5))
POLYGON ((3.5 1, 3.75 2, 4 1, 3.5 1))
```

--------------------------------

### Initialize Index and Data with Lettuce

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/full-text

Sets up a JSON index schema and populates it with initial data using Lettuce.

```java
import io.lettuce.core.*;
import io.lettuce.core.api.async.RedisAsyncCommands;

import io.lettuce.core.search.arguments.*;
import io.lettuce.core.search.SearchReply;

import io.lettuce.core.json.JsonPath;
import io.lettuce.core.json.JsonParser;
import io.lettuce.core.json.JsonObject;
import io.lettuce.core.api.StatefulRedisConnection;

import java.util.*;
import java.util.concurrent.CompletableFuture;

public class QueryFtExample {

    public void run() {
        RedisClient redisClient = RedisClient.create("redis://localhost:6379");

        try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
            RedisAsyncCommands<String, String> asyncCommands = connection.async();

            List<FieldArgs<String>> bicycleSchema = Arrays.asList(
                    TextFieldArgs.<String> builder().name("$.brand").as("brand").build(),
                    TextFieldArgs.<String> builder().name("$.model").as("model").build(),
                    TextFieldArgs.<String> builder().name("$.description").as("description").build(),
                    NumericFieldArgs.<String> builder().name("$.price").as("price").build(),
                    TagFieldArgs.<String> builder().name("$.condition").as("condition").build());

            CreateArgs<String, String> bicycleCreateArgs = CreateArgs.<String, String> builder().on(CreateArgs.TargetType.JSON)
                    .withPrefix("bicycle:").build();

            asyncCommands.ftCreate("idx:bicycle", bicycleCreateArgs, bicycleSchema).toCompletableFuture().join();

            JsonParser parser = asyncCommands.getJsonParser();

            List<JsonObject> bicycleJsons = Arrays.asList(parser.createJsonObject()
                    .put("brand", parser.createJsonValue("\"Velorim\"")).put("model", parser.createJsonValue("\"Jigger\""))
                    .put("description", parser
                            .createJsonValue("\"Small and powerful, the Jigger is the best ride for the smallest of tikes! "
                                    + "This is the tiniest kids’ pedal bike on the market available without a coaster brake, the Jigger "
                                    + "is the vehicle of choice for the rare tenacious little rider raring to go.\""))
                    .put("price", parser.createJsonValue("270")).put("condition", parser.createJsonValue("\"new\"")),
                    parser.createJsonObject().put("brand", parser.createJsonValue("\"Bicyk\""))
                            .put("model", parser.createJsonValue("\"Hillcraft\""))
                            .put("description",
                                    parser.createJsonValue("\"Kids want to ride with as little weight as possible. Especially "
                                            + "on an incline! They may be at the age when a 27.5'' wheel bike is just too clumsy coming "
                                            + "off a 24'' bike. The Hillcraft 26 is just the solution they need!\""))
                            .put("price", parser.createJsonValue("1200")).put("condition", parser.createJsonValue("\"used\"")),
                    parser.createJsonObject().put("brand", parser.createJsonValue("\"Nord\""))
                            .put("model", parser.createJsonValue("\"Chook air 5\""))
                            .put("description",
                                    parser.createJsonValue("\"Kids want to ride with as little weight as possible. Especially "
                                            + "on an incline! They may be at the age when a 27.5'' wheel bike is just too clumsy coming "
                                            + "off a 24'' bike. The Hillcraft 26 is just the solution they need!\""))
```

--------------------------------

### GEOSHAPE POLYGON example

Source: https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/geo

Example JSON object for a GEOSHAPE field with a POLYGON primitive.

```json
{
    "name": "Green Square",
    "geom": "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"
}
```

--------------------------------

### GEOSHAPE POINT example

Source: https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/geo

Example JSON object for a GEOSHAPE field with a POINT primitive.

```json
{
    "name": "Purple Point",
    "geom": "POINT (2 2)"
}
```

--------------------------------

### Calculate discounted price using APPLY

Source: https://redis.io/docs/latest/develop/ai/search-and-query/query/aggregation

Examples demonstrating how to calculate a discounted price for new bicycles using the APPLY clause.

```Redis CLI
FT.AGGREGATE idx:bicycle "@condition:{new}" LOAD 2 "__key" "price" APPLY "@price - (@price * 0.1)" AS "discounted"
```

```Python
search = Search(r, index_name="idx:bicycle")
aggregate_request = AggregateRequest(query='@condition:{new}') \
    .load('__key', 'price') \
    .apply(discounted='@price - (@price * 0.1)')
res = search.aggregate(aggregate_request)
print(len(res.rows)) # >>> 5
print(res.rows) # >>> [['__key', 'bicycle:0', ...
#[['__key', 'bicycle:0', 'price', '270', 'discounted', '243'],
# ['__key', 'bicycle:5', 'price', '810', 'discounted', '729'],
# ['__key', 'bicycle:6', 'price', '2300', 'discounted', '2070'],
# ['__key', 'bicycle:7', 'price', '430', 'discounted', '387'],
# ['__key', 'bicycle:8', 'price', '1200', 'discounted', '1080']]
```

--------------------------------

### Cursor read loop example

Source: https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/aggregations

Pseudo-code example demonstrating how to use cursors to iterate through all results.

```pseudocode
response, cursor = FT.AGGREGATE "idx" "redis" "WITHCURSOR";
while (1) {
  processResponse(response)
  if (!cursor) {
    break;
  }
  response, cursor = FT.CURSOR read "idx" cursor
}
```

--------------------------------

### Set configuration parameters at module load-time

Source: https://redis.io/docs/latest/develop/ai/search-and-query/administration/configuration

Methods for configuring the module during server startup via configuration files, CLI commands, or command line arguments.

```text
loadmodule ./redisearch.so [OPT VAL]...
```

```text
127.0.0.6379> MODULE LOAD redisearch.so [OPT VAL]...
```

```text
$ redis-server --loadmodule ./redisearch.so [OPT VAL]...
```
Tokens:
Raw