Dynamic filtering with Rules

Dynamic filtering with Rules search.

To help users find what they’re looking for straight from the search box, you can use Algolia Rules to automatically apply a filter to results if the query matches a facet value.

How to create a dynamic filtering rule

In this example for a product catalog, you create a rule that displays products with the “red” value in the color facet if the query contains the word “red”.

Using the example dataset, this rule ensures that only records with “red” in the color attribute are returned. It ignores “red” in other attributes such as brand.

Query	Results
red	FM, Clothing, LondonLook, Red, 21.99 The Mandal, Toaster, Black & Decker, Red, 149.99

Using the dashboard

1. Go to the Algolia dashboard and select your Algolia application.

2. On the left sidebar, select Search.

3. Select your Algolia index and go to the Rules page.

4. Select Create your first rule or New rule. In the drop-down menu, select the Manual Editor option.

5. In the Condition(s) section, with Query toggled on, select Contains from the menu, and enter red in the input.

6. In the Consequence(s) section:

   1. Click Add consequence and select Add Query Parameter.
   2. In the input, add the JSON parameters you want to apply when the user’s query matches the Rule: {"filters":"color:red"}
   3. Click Add consequence and select Remove Word.
   4. Enter red in the input.

   If you click Optional under Consequence(s), this will display non-red products after the red ones. For more information, see Optional filters.

7. Save your changes.

Using the API

This example uses the filters parameter. With this approach, you need one rule per filter value. If you have 10 color options, you need 10 rules, one for each color.

C#

var response = await client.SaveRuleAsync(
  "ALGOLIA_INDEX_NAME",
  "red-color",
  new Rule
  {
    ObjectID = "red-color",
    Conditions = new List
    {
      new Condition { Pattern = "red", Anchoring = Enum.Parse("Contains") },
    },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        Query = new ConsequenceQuery(
          new ConsequenceQueryObject { Remove = new List { "red" } }
        ),
        Filters = "color:red",
      },
    },
  }
);

Example: one rule per facet

Instead of creating one rule per facet value, this approach uses one rule for the color facet.

Using the example dataset, this single rule ensures that any record with any matching color value in the color attribute is returned.

Query	Results
red	FM, Clothing, LondonLook, Red, 21.99
	The Mandal, Toaster, Black & Decker, Red, 149.99
black	Will Carpenter, T-shirt, Red or Dead, Black, 199.99

Using the dashboard

1. Create a new rule. See how to create a dynamic filtering rule.

2. In the Manual Editor’s Condition(s) section, click the box next to Query contains and select the option Add Facet “color” from the drop-down menu.

3. In the Consequence(s) section:

   1. Click Add consequence and select Filter/Boost Matching Attributes.
   2. Click the Filter box and select the option Add Facet “color” from the drop-down menu.

4. Save your changes.

Using the API

C#

var response = await client.SaveRuleAsync(
  "ALGOLIA_INDEX_NAME",
  "color-facets",
  new Rule
  {
    ObjectID = "color-facets",
    Conditions = new List { new Condition { Pattern = "{facet:color}" } },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        AutomaticFacetFilters = new AutomaticFacetFilters(
          new List { new AutomaticFacetFilter { Facet = "color" } }
        ),
      },
    },
  }
);

Numerical dynamic filtering

Consider a user entering the query “cheap toaster 800w”. You can use two rules together to filter results by:

1. The product type: "Toaster"
2. “Cheapness”. You determine that a cheap product is any product that costs less than $15.

Using the example dataset, these rules ensure that any product that costs less than $15, has the product_type “Toaster” and includes the phrase “800w” is returned.

Query	Results
cheap toaster 800w	Essentials 800w, Toaster, Daewoo, Black, 14.99

Using the dashboard

Create the first rule:

1. Create a new rule. See How to create a dynamic filtering rule.

2. In the Manual Editor’s Condition(s) section, with Query toggled on, select Contains in the drop-down menu, and enter “toaster” in the input field.

3. In the Consequence(s) section:

   1. Click Add consequence and select Add Query Parameter.
   2. In the input field that appears, enter {"filters":"product_type:toaster"}
   3. Click Add consequence and select Remove Word.
   4. Type or select “toaster” in the input field.

4. Save your changes.

Create the second rule:

1. Create a new rule

2. In the Manual Editor’s Condition(s), with Query toggled on, select Contains in the drop-down menu, and enter “cheap” in the input field.

3. In the Consequence(s) section:

   1. Click Add consequence and select Add Query Parameter.
   2. In the input field that appears, enter {"filters":"price < 10"}
   3. Click Add consequence and select Remove Word.
   4. Type or select “cheap” in the input field.

4. Save your changes.

Using the API

C#

var response = await client.SaveRulesAsync(
  "ALGOLIA_INDEX_NAME",
  new List
  {
    new Rule
    {
      ObjectID = "toaster",
      Conditions = new List
      {
        new Condition { Pattern = "toaster", Anchoring = Enum.Parse("Contains") },
      },
      Consequence = new Consequence
      {
        Params = new ConsequenceParams
        {
          Query = new ConsequenceQuery(
            new ConsequenceQueryObject { Remove = new List { "toaster" } }
          ),
          Filters = "product_type:toaster",
        },
      },
    },
    new Rule
    {
      ObjectID = "cheap",
      Conditions = new List
      {
        new Condition { Pattern = "cheap", Anchoring = Enum.Parse("Contains") },
      },
      Consequence = new Consequence
      {
        Params = new ConsequenceParams
        {
          Query = new ConsequenceQuery(
            new ConsequenceQueryObject { Remove = new List { "cheap" } }
          ),
          Filters = "price < 15",
        },
      },
    },
  }
);

Tagged filters

Consider a user who enters the query “apple headphones”. They would expect to search for results that match the term “headphones”, but only where the brand attribute matches “apple”. You can find this behavior on sites such as GitHub. It’s a great alternative to filters for users who prefer to type rather than click.

This approach is similar to one rule per facet.

Using the example dataset, this rule ensures that any record containing the phrase “headphones” that also has “Apple” in the brand attribute will be returned. It won’t return non-Apple brands, even if the phrase “Apple” appears in other attributes.

Query	Results
apple headphones	Airpods Max, Headphones, Apple, Gray, 548.99

Using the dashboard

1. Create a new rule as above

2. In the Manual Editor’s Condition(s), click the box next to Query contains and select the option Add Facet “brand” from the drop-down menu.

3. Clear the Apply to plurals, synonyms and typos checkbox to ensure precise matching of the brand name.

4. In the Consequence(s) section:

   1. Click Add consequence and select Filter/Boost Matching Attributes.
   2. Click the Filter box that appears and select the option Add Facet “brand” from the drop-down menu.
   3. Click Add consequence and select Remove word.
   4. In the input that appears, select Remove {facet:brand}.

5. Save your changes.

Using the API

C#

var response = await client.SaveRuleAsync(
  "ALGOLIA_INDEX_NAME",
  "tagged-brand-rule",
  new Rule
  {
    Conditions = new List
    {
      new Condition
      {
        Pattern = "brand: {facet:brand}",
        Anchoring = Enum.Parse("Contains"),
        Alternatives = false,
      },
    },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        AutomaticFacetFilters = new AutomaticFacetFilters(
          new List { new AutomaticFacetFilter { Facet = "brand" } }
        ),
        Query = new ConsequenceQuery(
          new ConsequenceQueryObject
          {
            Remove = new List { "brand:", "{facet:brand}" },
          }
        ),
      },
    },
    Description = "filter on brand: {brand}",
    ObjectID = "tagged-brand-rule",
  }
);

Example dataset

All the examples on this page use a product catalog index. The appropriate attributes are set as attributes for faceting. The index has records that look like this:

JSON

[
  {
    "product_name": "FM",
    "product_type": "T-shirt",
    "brand": "LondonLook",
    "color": "Red",
    "price": 21.99
  },
  {
    "product_name": "Caveman",
    "product_type": "T-shirt",
    "brand": "Red or Dead",
    "color": "Brown",
    "price": 9.99
  },
  {
    "product_name": "iPhone 13 Pro Max",
    "product_type": "Phone",
    "brand": "Apple",
    "color": "Blue",
    "price": 1824.61
  },
  {
    "product_name": "Will Carpenter",
    "product_type": "T-shirt",
    "brand": "Red or Dead",
    "color": "Black",
    "price": 199.99
  },
  {
    "product_name": "The Mandal 800w",
    "product_type": "Toaster",
    "brand": "Black & Decker",
    "color": "Red",
    "price": 149.99
  },
  {
    "product_name": "Essentials 800w",
    "product_type": "Toaster",
    "brand": "Daewoo",
    "color": "Black",
    "price": 14.99
  },
  {
    "product_name": "Airpods Max",
    "product_type": "Headphones",
    "brand": "Apple",
    "color": "Gray",
    "price": 548.99
  },
  {
    "product_name": "WH-CH520",
    "product_type": "Headphones",
    "brand": "Sony",
    "color": "Apple",
    "price": 39.99
  }
]

See also

• Adding filters based on the query
• Faceting