Guides / Managing results / Rules / Detecting intent

Adding filters based on the query

On this page

Sometimes, specific terms can act as cues that you can use to filter search results. You can use positive, negative, or numerical filters:

  • Positive filters include a specific subset of matching records in the results. For example, if a user types “diet” on a restaurant website, return every record that has “low-carb” or “low-fat”.
  • Negative filters exclude matching records from results. For example, if a user types “gluten-free” on a restaurant website, you could filter out any gluten-containing meal.
  • Numerical filters convert text queries into a numerical range. For example, if a user types “cheap” on a website for kitchen appliances, you could filter out anything costing more than $50.
Guides Faceting
Filtering
Merchandising
Blog Filters and facets in site search

Positive filters

If you want to filter out every non-diet-friendly meal whenever user’s search queries contain the term “diet”, you could use the _tags attribute to categorize meals depending on their individual qualities:

Copy 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

[
  {
    "name": "Chicken Stuffed Baked Avocados",
    "restaurant": "The Hive",
    "_tags": ["low-carb"]
  },
  {
    "name": "Spinach Quiche",
    "restaurant": "Bert's Inn",
    "_tags": ["low-carb", "vegetarian"]
  },
  {
    "name": "Pizza Chicken Bake",
    "restaurant": "Millbrook Deli",
    "_tags": ["cheese"]
  },
  {
    "name": "Strawberry Sorbet",
    "restaurant": "The Hive",
    "_tags": ["low-fat", "vegetarian", "vegan"]
  }
]

When users include the term “diet” in their search, you want to automatically return every record that has “low-carb” or “low-fat” in their _tags attribute. Because _tags is already optimized for filtering, you don’t have to set it as an attribute for faceting. You can directly create a new Rule that detects the term “diet” in a query and applies a positive filter on tags “low-carb” and “low-fat”.

To use the term “diet” only for filtering and not as a search term, add a consequence in your rule to remove the word from your query.

Using the API

To add a rule, use the saveRule method. When creating a rule, you must define a condition and a consequence.

Copy 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

var response = await client.SaveRuleAsync(
  "ALGOLIA_INDEX_NAME",
  "diet-rule",
  new Rule
  {
    ObjectID = "diet-rule",
    Conditions = new List<Condition>
    {
      new Condition { Pattern = "diet", Anchoring = Enum.Parse<Anchoring>("Contains") },
    },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        Filters = "'low-carb' OR 'low-fat'",
        Query = new ConsequenceQuery(
          new ConsequenceQueryObject
          {
            Edits = new List<Edit>
            {
              new Edit { Type = Enum.Parse<EditType>("Remove"), Delete = "diet" },
            },
          }
        ),
      },
    },
  }
);

Using the dashboard

You can also add rules from the Algolia dashboard.

  1. Select the Search product icon on your dashboard.
  2. Select the Rules section from the left sidebar menu in the Algolia dashboard.
  3. Under the heading Rules, select the index to which you’re adding a Rule.
  4. Select Create your first rule or New rule. In the drop-down menu, select Manual Editor.
  5. In the Condition(s) sections, keep Query contains and enter “diet” in the input field.
  6. In the Consequence(s) section:
    • Click the Add consequence button and select Add Query Parameter.
    • In the input field that appears, enter the JSON search parameter you want to add. For example: { "filters": "'low-carb' OR 'low-fat'" }.
    • Click the Add consequence button again and select Remove Word.
    • Type or select “diet” in the input field.
  7. Save your changes.

Negative filters

To exclude gluten-containing foods from the search results, when a user searches for gluten-free meals: To do this:

  1. Create an allergens attribute (with “gluten” as one of the potential values).
  2. Create a rule that filters out records with “gluten” in that attribute.

Example records

Copy 
1
2
3
4
5
6
7
8
9
10
11
12

[
  {
    "name": "Pasta Bolognese",
    "restaurant": "Millbrook Deli",
    "allergens": ["eggs", "lactose"]
  },
  {
    "name": "Breakfast Waffles",
    "restaurant": "The Hive",
    "allergens": ["gluten", "lactose"]
  }
]

Using the API

Set allergens as an attributesForFaceting in your index:

Copy 
1
2
3
4

var response = await client.SetSettingsAsync(
  "ALGOLIA_INDEX_NAME",
  new IndexSettings { AttributesForFaceting = new List<string> { "allergens" } }
);
  • Use the saveRule method to create a rule that detects the term “gluten-free” in a query and applies a negative filter on facet value allergens:gluten.
  • Add a consequence in your rule to remove the word “gluten-free” from your query. This way, it won’t be used as a search term, only for filtering purposes.
Copy 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

var response = await client.SaveRuleAsync(
  "ALGOLIA_INDEX_NAME",
  "gluten-free-rule",
  new Rule
  {
    ObjectID = "gluten-free-rule",
    Conditions = new List<Condition>
    {
      new Condition { Pattern = "gluten-free", Anchoring = Enum.Parse<Anchoring>("Contains") },
    },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        Filters = "NOT allergens:gluten",
        Query = new ConsequenceQuery(
          new ConsequenceQueryObject
          {
            Edits = new List<Edit>
            {
              new Edit { Type = Enum.Parse<EditType>("Remove"), Delete = "gluten-free" },
            },
          }
        ),
      },
    },
  }
);

Using the dashboard

You can also add rules from the Algolia dashboard.

  1. Select the Search product icon on your dashboard and then select your index.
  2. Click the Configuration tab.
  3. In the Facets subsection of Filtering and Faceting, click the “Add an attribute” button and select the allergens attribute from the drop-down menu.
  4. Click the Rules tab.
  5. Select Create your first rule or New rule. In the drop-down menu, select Manual Editor.
  6. In the Condition(s) section, keep Query toggled on, select Contains in the drop-down menu, and enter “gluten-free” in the input field.
  7. In the Consequence(s) section:
    • Click the Add consequence button and select Add Query Parameter.
    • In the input field that appears, enter the JSON search parameter you want to add. For example: { "filters": "NOT allergens:gluten" }
    • Click the Add consequence button again and select Remove Word.
    • Type or select “gluten-free” in the input field.
  8. Save your changes.

Numerical filters

Consider the query “cheap toaster 800w”. You can use Rules to filter the results by “toaster” and “prices between 0 and 25” so that the only textual search is the remaining term, “800w”, which could further be used to limit the results with that wattage.

Rule

If query = “cheap toaster” then price < 10 and type=toaster

This requires two rules.

Using the API

Copy 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

Using the dashboard

Since there are two rules, you must set up both separately.

Preparation

  1. Select the Search product icon on your dashboard and then select your index.
  2. Click the Configuration tab.
  3. In the Facets subsection of Filtering and Faceting, click the “Add an attribute” button and select the product_type attribute from the drop-down menu.

For the first rule

  1. Select the Rules section from the left sidebar menu in the Algolia dashboard.
  2. Under the heading Rules, select the index to which you’re adding a rule.
  3. Select Create your first rule or New rule. In the drop-down menu, click the Manual Editor option.
  4. In the Condition(s) section, keep Query toggled on, select Contains in the drop-down menu, and enter “toaster” in the input field.
  5. In the Consequence(s) section:
    • Click the Add consequence button and select Add Query Parameter.
    • In the input field that appears, add the JSON parameters you want to apply when the user’s query matches the Rule: { "filters": "product_type:toaster" }
    • Click the Add consequence button again and select Remove Word.
    • Type or select “toaster” in the input field.
  6. Save your changes.

For the second rule

  1. Go back to the Rules section.
  2. Select New rule. In the drop-down menu, click the Manual Editor option.
  3. In the Condition(s) section, keep Query toggled on, select Contains in the drop-down menu, and enter “cheap” in the input field.
  4. In the Consequence(s) section:
    • Click the Add consequence button and select Add Query Parameter.
    • In the input field that appears, add the JSON parameters you want to apply when the user’s query matches the Rule: { "filters": "price<10" }
    • Click the Add consequence button again and select Remove Word.
    • Type or select “cheap” in the input field.
  5. Save your changes.
Did you find this page helpful?