Detect keywords

You can use rules to detect a specific word and modify a parameter because of this word.

Limit the search to only a subset of attributes

A good example of altering a query is with an online document library that allows keyword searches inside documents. If a user types in the word “article ref21”, they’re probably looking for an article whose title or ID contains “ref21”._

Rule

If query = “article ref21” then remove article and search for an article whose title or ID contains ‘ref21’

Using the API

To run the code examples on this page, install the latest API client.

var response = await client.SaveRuleAsync(
  "INDEX_NAME",
  "article-rule",
  new Rule
  {
    ObjectID = "article-rule",
    Conditions = new List<Condition>
    {
      new Condition { Pattern = "article", Anchoring = Enum.Parse<Anchoring>("StartsWith") },
    },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        Query = new ConsequenceQuery(
          new ConsequenceQueryObject
          {
            Edits = new List<Edit>
            {
              new Edit { Type = Enum.Parse<EditType>("Remove"), Delete = "article" },
            },
          }
        ),
        RestrictSearchableAttributes = new List<string> { "title", "book_id" },
      },
    },
  }
);

final response = await client.saveRule(
  indexName: "INDEX_NAME",
  objectID: "article-rule",
  rule: Rule(
    objectID: "article-rule",
    conditions: [
      Condition(
        pattern: "article",
        anchoring: Anchoring.fromJson("startsWith"),
      ),
    ],
    consequence: Consequence(
      params: ConsequenceParams(
        query: ConsequenceQueryObject(
          edits: [
            Edit(
              type: EditType.fromJson("remove"),
              delete: "article",
            ),
          ],
        ),
        restrictSearchableAttributes: [
          "title",
          "book_id",
        ],
      ),
    ),
  ),
);

response, err := client.SaveRule(client.NewApiSaveRuleRequest(
  "INDEX_NAME", "article-rule",
  search.NewEmptyRule().SetObjectID("article-rule").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("article").SetAnchoring(search.Anchoring("startsWith"))}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetQuery(search.ConsequenceQueryObjectAsConsequenceQuery(
        search.NewEmptyConsequenceQueryObject().SetEdits(
          []search.Edit{
            *search.NewEmptyEdit().SetType(search.EditType("remove")).SetDelete("article"),
          }),
      )).SetRestrictSearchableAttributes(
        []string{"title", "book_id"})))))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.saveRule(
  "INDEX_NAME",
  "article-rule",
  new Rule()
    .setObjectID("article-rule")
    .setConditions(Arrays.asList(new Condition().setPattern("article").setAnchoring(Anchoring.STARTS_WITH)))
    .setConsequence(
      new Consequence().setParams(
        new ConsequenceParams()
          .setQuery(new ConsequenceQueryObject().setEdits(Arrays.asList(new Edit().setType(EditType.REMOVE).setDelete("article"))))
          .setRestrictSearchableAttributes(Arrays.asList("title", "book_id"))
      )
    )
);

const response = await client.saveRule({
  indexName: 'indexName',
  objectID: 'article-rule',
  rule: {
    objectID: 'article-rule',
    conditions: [{ pattern: 'article', anchoring: 'startsWith' }],
    consequence: {
      params: {
        query: { edits: [{ type: 'remove', delete: 'article' }] },
        restrictSearchableAttributes: ['title', 'book_id'],
      },
    },
  },
});

var response =
  client.saveRule(
    indexName = "INDEX_NAME",
    objectID = "article-rule",
    rule =
      Rule(
        objectID = "article-rule",
        conditions =
          listOf(
            Condition(
              pattern = "article",
              anchoring = Anchoring.entries.first { it.value == "startsWith" },
            )
          ),
        consequence =
          Consequence(
            params =
              ConsequenceParams(
                query =
                  ConsequenceQueryObject(
                    edits =
                      listOf(
                        Edit(
                          type = EditType.entries.first { it.value == "remove" },
                          delete = "article",
                        )
                      )
                  ),
                restrictSearchableAttributes = listOf("title", "book_id"),
              )
          ),
      ),
  )

$response = $client->saveRule(
    'INDEX_NAME',
    'article-rule',
    ['objectID' => 'article-rule',
        'conditions' => [
            ['pattern' => 'article',
                'anchoring' => 'startsWith',
            ],
        ],
        'consequence' => ['params' => ['query' => ['edits' => [
            ['type' => 'remove',
                'delete' => 'article',
            ],
        ],
        ],
            'restrictSearchableAttributes' => [
                'title',

                'book_id',
            ],
        ],
        ],
    ],
);

response = client.save_rule(
    index_name="INDEX_NAME",
    object_id="article-rule",
    rule={
        "objectID": "article-rule",
        "conditions": [
            {
                "pattern": "article",
                "anchoring": "startsWith",
            },
        ],
        "consequence": {
            "params": {
                "query": {
                    "edits": [
                        {
                            "type": "remove",
                            "delete": "article",
                        },
                    ],
                },
                "restrictSearchableAttributes": [
                    "title",
                    "book_id",
                ],
            },
        },
    },
)

response = client.save_rule(
  "INDEX_NAME",
  "article-rule",
  Algolia::Search::Rule.new(
    algolia_object_id: "article-rule",
    conditions: [Algolia::Search::Condition.new(pattern: "article", anchoring: "startsWith")],
    consequence: Algolia::Search::Consequence.new(
      params: Algolia::Search::ConsequenceParams.new(
        query: Algolia::Search::ConsequenceQueryObject.new(
          edits: [Algolia::Search::Edit.new(type: "remove", delete: "article")]
        ),
        restrict_searchable_attributes: ["title", "book_id"]
      )
    )
  )
)

val response = Await.result(
  client.saveRule(
    indexName = "INDEX_NAME",
    objectID = "article-rule",
    rule = Rule(
      objectID = "article-rule",
      conditions = Some(
        Seq(
          Condition(
            pattern = Some("article"),
            anchoring = Some(Anchoring.withName("startsWith"))
          )
        )
      ),
      consequence = Consequence(
        params = Some(
          ConsequenceParams(
            query = Some(
              ConsequenceQueryObject(
                edits = Some(
                  Seq(
                    Edit(
                      `type` = Some(EditType.withName("remove")),
                      delete = Some("article")
                    )
                  )
                )
              )
            ),
            restrictSearchableAttributes = Some(Seq("title", "book_id"))
          )
        )
      )
    )
  ),
  Duration(100, "sec")
)

let response = try await client.saveRule(
    indexName: "INDEX_NAME",
    objectID: "article-rule",
    rule: Rule(
        objectID: "article-rule",
        conditions: [SearchCondition(pattern: "article", anchoring: SearchAnchoring.startsWith)],
        consequence: SearchConsequence(params: SearchConsequenceParams(
            restrictSearchableAttributes: ["title", "book_id"],
            query: SearchConsequenceQuery
                .searchConsequenceQueryObject(SearchConsequenceQueryObject(edits: [SearchEdit(
                    type: SearchEditType.remove,
                    delete: "article"
                )]))
        ))
    )
)

Using the dashboard

You can add this rule from the Algolia dashboard using either the Visual Editor or the Manual Editor. The title and id attributes must already be in your index’s searchableAttributes.

Visual Editor
Manual Editor

In the Algolia dashboard, select your application and index, open Rules, and select New rule > Visual Editor.
Click Set query condition(s), select contains, enter article, and click Apply.
In Consequences, expand More consequences and select Apply search parameters. Enter { "restrictSearchableAttributes": ["title", "id"] } in Value and click Apply.
Click Add Consequence, expand More consequences, and select Remove word. Enter article in Word(s) and click Apply.
Preview the results for article ref21, click Review and Publish, and click Publish.

In the Algolia dashboard, select Search, select your , and open Rules. Select Create your first rule or New rule, then select Manual Editor.
In Condition(s), keep Query selected, select Contains, and enter article.
In Consequence(s), click Add consequence and select Add Query Parameter. Enter { "restrictSearchableAttributes": ["title", "id"] }.
Click Add consequence again and select Remove Word. Enter article.
Save your changes.

Search and Discovery platform

Optimization and Personalization

AI-powered experiences

Production and scale

Detect keywords

Limit the search to only a subset of attributes

Rule

Using the API

Using the dashboard

​Limit the search to only a subset of attributes

​Rule

​Using the API

​Using the dashboard

Limit the search to only a subset of attributes

Rule

Using the API

Using the dashboard