relevancyStrictness

Threshold for including results in relevant sorts

Options

100

Default value. Returns and sorts only the top relevant results.

90

Includes records with at least 90% similarity to the most relevant result.

0

Returns up to paginationLimitedTo results (if there’s no timeout), sorted using the customRanking of your relevant sort.

Usage

• Only available on applications with the Relevant sort feature enabled.
• Can only be set on virtual replicas.
• Accepts integer values from 0 to 100 (inclusive).
• Lower values include more results but may reduce precision.
• You can test values manually or through an A/B test to find the optimal balance between result relevancy and recall.

Examples

Set the default relevancy strictness for an index with Relevant sort

Current API clients

C#

var response = await client.SetSettingsAsync(
  "INDEX_NAME",
  new IndexSettings
  {
    CustomRanking = new List<string> { "asc(textual_attribute)" },
    RelevancyStrictness = 0,
  }
);

final response = await client.setSettings(
  indexName: "INDEX_NAME",
  indexSettings: IndexSettings(
    customRanking: [
      "asc(textual_attribute)",
    ],
    relevancyStrictness: 0,
  ),
);

response, err := client.SetSettings(client.NewApiSetSettingsRequest(
  "INDEX_NAME",
  search.NewEmptyIndexSettings().SetCustomRanking(
    []string{"asc(textual_attribute)"}).SetRelevancyStrictness(0)))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.setSettings(
  "INDEX_NAME",
  new IndexSettings().setCustomRanking(Arrays.asList("asc(textual_attribute)")).setRelevancyStrictness(0)
);

const response = await client.setSettings({
  indexName: 'theIndexName',
  indexSettings: { customRanking: ['asc(textual_attribute)'], relevancyStrictness: 0 },
});

var response =
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings =
      IndexSettings(customRanking = listOf("asc(textual_attribute)"), relevancyStrictness = 0),
  )

$response = $client->setSettings(
    'INDEX_NAME',
    ['customRanking' => [
        'asc(textual_attribute)',
    ],
        'relevancyStrictness' => 0,
    ],
);

response = client.set_settings(
    index_name="INDEX_NAME",
    index_settings={
        "customRanking": [
            "asc(textual_attribute)",
        ],
        "relevancyStrictness": 0,
    },
)

response = client.set_settings(
  "INDEX_NAME",
  Algolia::Search::IndexSettings.new(custom_ranking: ["asc(textual_attribute)"], relevancy_strictness: 0)
)

val response = Await.result(
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(
      customRanking = Some(Seq("asc(textual_attribute)")),
      relevancyStrictness = Some(0)
    )
  ),
  Duration(100, "sec")
)

let response = try await client.setSettings(
    indexName: "INDEX_NAME",
    indexSettings: IndexSettings(customRanking: ["asc(textual_attribute)"], relevancyStrictness: 0)
)

Legacy API clients

C#

var settings = new IndexSettings();
settings.RelevancyStrictness = 90;

res, err := index.SetSettings(search.Settings{
	RelevancyStrictness: opt.RelevancyStrictness(90),
})

index.setSettings(
  new IndexSettings().setRelevancyStrictness(90)
);

index
  .setSettings({
    relevancyStrictness: 90,
  })
  .then(() => {
    // done
  });

val settings = settings {
    relevancyStrictness = 90
}

index.setSettings(settings)

$index->setSettings([
  'relevancyStrictness' => 90
]);

index.set_settings({"relevancyStrictness": 90})

index.set_settings(
  {
    relevancyStrictness: 90
  }
)

client.execute {
  setSettings of "myIndex" `with` IndexSettings(
    relevancyStrictness = Some(90)
  )
}

let settings = Settings()
  .set(\.RelevancyStrictness, to: 90)

index.setSettings(settings) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

Override the default relevancy strictness for the current search

Current API clients

C#

var response = await client.SearchSingleIndexAsync<Hit>(
  "INDEX_NAME",
  new SearchParams(new SearchParamsObject { Query = "query", RelevancyStrictness = 70 })
);

final response = await client.searchSingleIndex(
  indexName: "INDEX_NAME",
  searchParams: SearchParamsObject(
    query: "query",
    relevancyStrictness: 70,
  ),
);

response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
  "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
  search.NewEmptySearchParamsObject().SetQuery("query").SetRelevancyStrictness(70))))
if err != nil {
  // handle the eventual error
  panic(err)
}

SearchResponse response = client.searchSingleIndex(
  "INDEX_NAME",
  new SearchParamsObject().setQuery("query").setRelevancyStrictness(70),
  Hit.class
);

const response = await client.searchSingleIndex({
  indexName: 'indexName',
  searchParams: { query: 'query', relevancyStrictness: 70 },
});

var response =
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams = SearchParamsObject(query = "query", relevancyStrictness = 70),
  )

$response = $client->searchSingleIndex(
    'INDEX_NAME',
    ['query' => 'query',
        'relevancyStrictness' => 70,
    ],
);

response = client.search_single_index(
    index_name="INDEX_NAME",
    search_params={
        "query": "query",
        "relevancyStrictness": 70,
    },
)

response = client.search_single_index(
  "INDEX_NAME",
  Algolia::Search::SearchParamsObject.new(query: "query", relevancy_strictness: 70)
)

val response = Await.result(
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams = Some(
      SearchParamsObject(
        query = Some("query"),
        relevancyStrictness = Some(70)
      )
    )
  ),
  Duration(100, "sec")
)

let response: SearchResponse<Hit> = try await client.searchSingleIndex(
    indexName: "INDEX_NAME",
    searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
        query: "query",
        relevancyStrictness: 70
    ))
)

Legacy API clients

C#

index.Search(new Query("query")
{
    RelevancyStrictness = 70
});

res, err := index.Search(
	"query",
	opt.RelevancyStrictness(70),
)

index.search(
  new Query("").setRelevancyStrictness(70)
);

index
  .search("query", {
    relevancyStrictness: 70,
  })
  .then(({ hits }) => {
    console.log(hits);
  });

val query = query("query") {
    relevancyStrictness = 70
}

index.search(query)

$results = $index->search('query', [
  'relevancyStrictness' => 70
]);

results = index.search("query", {"relevancyStrictness": 70})

results = index.search(
  "query",
  {
    relevancyStrictness: 70
  }
)

client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    relevancyStrictness = Some(70)
  )
}

let query = Query("query")
  .set(\.RelevancyStrictness, to: 70)

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}