How to implement faceting, an enhancement to the display of search results

About Faceting

To make it easier for users to quickly spot the most relevant search results, add faceting functionality. With faceting, search results are grouped under useful headings, using tags you apply ahead of time to the documents in your index. For example, the results of a shopping query for books might be grouped according to the type of book and the price:

Each time the user clicks a facet value, the set of results is reduced to only the items that have that value. Additional clicks continue to narrow down the search—the previous facet values are remembered and applied again. For example, the user might click "Cookbooks," and see a list of all 10 cookbook titles next to an updated navigation list like this:

If price is more important to the user than the reviews of fellow shoppers, the next click would be on a price range, say "$10-19.99." Now the list might look like this:

At this point, it is very easy for the user to choose the right cookbook.

Why Use Faceting?

Faceted search results provide an easy-to-scan, browsable display that helps users quickly narrow down each search. The faceting tags that you store with your Searchify documents provide a way to add your own taxonomy to directly control the presentation of search results. In the end, it's about helping the user find the right information. Faceted search gives a user the power to create an individualized navigation path, drilling down through successive refinements to reach the right document. This more effectively mirrors the intuitive thought patterns of most users. Faceted search has become an expected feature, particularly for commerce sites.

How It Works

Faceted search is performed in several parts:

• Index: to each document in the index, add tags to specify a value for each facet. For example, for each book in the index, tag it with the type of material and the price range.
• Search results: for every search, the Searchify server returns a count of how many matching documents were tagged with each value within each facet. For example, if the query was for "books," you might find out that in the facet "type of material," your index contains 13 science fiction books, 15 romance novels, and 10 cookbooks; and in the price facet, there are 5 books under $10, 200 books from $10-19.99, and so on.
• Query: you can include facet values as query criteria. For example, you can write a query that returns only the romance novels under $10.
• Web page: use the facets and document counts returned by the server to create a set of facet links on your web page, like the example shown above. Then construct queries to be activated by each facet link, passing in the appropriate values—say, querying only for romance novels when the user clicks the "Romance (15)" link.

Quick Start: Copy & Paste

Tweak the following code snippets for your needs, and you're ready to go

Before you start

• • 
  • 
  • 
  • 

  For Ruby environments we provide a gem that handles all the REST calls for you in a very Ruby-fashioned way.

  • Download the Ruby client if you have not already done so.
  • Know your index's public URL. You'll need it to instantiate the client. Find the public URL on the Dashboard.

  For Python environments we provide a package that handles all the REST calls for you. You can install it with Pip or download the library:

  • Download the Python client if you have not already done so.
  • Know your index's public URL. You'll need it to instantiate the client. Find the public URL on the Dashboard.

  For Php environments we provide a client that handles all the REST calls for you. Download a file that comes with the library ready to use.

  • Download the PHP client if you have not already done so.
  • Know your index's public URL. You'll need it to instantiate the client. Find the public URL on the Dashboard.

  For Java environments we provide a basic API client that handles all the REST calls for you and translates the responses to simple Java objects.

  • Download the Java client if you have not already done so.
  • Know your index's public URL. You'll need it to instantiate the client. Find the public URL on the Dashboard.

Tag the documents

categories = { 
                  'priceRange' => '$10-$19.99',
                  'bookType' => 'cookbook'
             }

index.document(docid).update_categories(categories) 

categories = { 
                  'priceRange': '$10-$19.99',
                  'bookType': 'cookbook'
             }

index.update_categories(docid, categories) 

categories = array('priceRange' => '$10-$19.99',
                   'bookType' => 'cookbook');

$index->update_categories($docid, $categories); 

Map<String, String> categories = new HashMap<String, String>();
categories.put("priceRange", "$10-$19.99");
categories.put("bookType", "cookbook");

index.updateCategories(docId, categories);

{
   'bookType': {
       'cookbook': 2,
       'travel': 4
   },
   'priceRange': {
       'Less than $10': 1,
       '$10-$19.99': 5
   }
}

This shows that there are both cookbooks and travel books related to France, and most of them are between $10 and $20.

Use Facets as Query Criteria

You can filter a search by using facet values. This is similar to using document variables, but uses different syntax. For example, suppose you want to find cookbooks that cost less than $20.00. The following code shows how to do that search by using .withCategoryFilters to include facet values in a query:

index.search(query,
             :category_filters => {
                'priceRange' => ['Less than $10', '$10-$19.99'],
                'bookType' => ['cookBook']
             })

index.search(query,
             category_filters={
                'priceRange': ['Less than $10', '$10-$19.99'],
                'bookType': ['cookBook']
             })

$index.search($query, NULL, NULL, NULL, NULL, NULL,
             array('priceRange' => array('Less than $10', '$10-$19.99'),
                   'bookType' => array('cookBook'))
             );

Map<String, List<String>> filters =
       new HashMap<String, List<String>>();
filters.put("priceRange",
           Arrays.asList("Less than $10", "$10-$19.99"));
filters.put("bookType",
           Arrays.asList("cookbook"));

results = index.search(Query.forString(query)
                       .withCategoryFilters(filters));

Designing a Faceting Taxonomy

Before you start implementing faceting, take some time to decide on which facets and values make sense for your index. When you consider how to categorize information, all sorts of interesting questions can arise. Depending on the size of your index and whether you are working in a large enterprise, you might need to hold a few meetings involving key people such as website designers, product managers, information architects, and others.

The goal of your design phase is to arrive at a scheme, probably a written list, that defines the facets and their values. For example, suppose you are dealing with the books database from our earlier example. If you decide that one facet is "type of book," what are the book types you want to feature? You'll need to answer questions like these:

• Will you base the list on which types are most numerous in your index, on which types people most often purchase, or on some other criteria?
• How many book types do you want to tag before grouping the remaining books into an "Other" category?
• At what cutoff point does a type of book fall into "Other": if there are fewer than 100 books of that type in the index ... fewer than 10 ... or fewer than 10 purchased in the past quarter?
• Do you want to keep the book type groups fairly even in size? For example, if you have 100 mystery novels and only a few books of every other type, do you want to break down the "mystery" group into smaller sub-groups, such as "Noir," "Thriller," and "Sherlock Holmes"?

From this example, you can see that a taxonomy can be both complex and dynamic—the design might need to change over time to reflect changes in index contents, business goals, and sales fluctuations.

More Information

• Faceted Search Pattern—Martijn van Welie
• Flamenco Search Interface Project—several scholarly papers on the original research that gave rise to the idea of faceted search
• Faceting: a quick demo of a shopping search engine—IndexTank Blog