Use BM25 score from Elasticsearch to order gremlin results

[muxalko]

How can I get Gremlin search results sorted according to Okapi BM25 relevance score provided by Elasticsearch?

I want to use mixed index with number of vertex properties indexed as TEXT in ES and get the results based on full-text search with different boost weights.

For example, having my mixed index include:

• Property "Name" with boost weight of 5
• Property "Topic" with boost weight of 4
• Property "Desc" with boost weight of 1

mgmt.buildIndex('myIndex', Vertex.class)
.addKey(nameProperty, Mapping.TEXT.asParameter(), Parameter.of(ParameterType.customParameterName("boost"), 5))
.addKey(topicProperty, Mapping.TEXT.asParameter(), Parameter.of(ParameterType.customParameterName("boost"), 4))
.addKey(descProperty, Mapping.TEXT.asParameter(), Parameter.of(ParameterType.customParameterName("boost"), 1))
.buildMixedIndex("search")

I would expect the results to be sorted with the relevance score in mind as I execute my query, or get the score together with gremlin response to sort it later in the application.

g.V().or(
  has('Name',textContainsPrefix("ProjectA")),
  has('Topic',textContainsPrefix("ProjectA"))
  has('Desc',textContainsPrefix("ProjectA"))
).order().by(score, desc)

I could achieve the desired results by querying index directly with indexQuery() method, getting the correct relevance score with getScore(), but I would very much like to have it working within gremlin.

If it is not currently implemented, perhaps there is a way to customize the query and inject my own sorting/ordering mechanism using some smart mechanics like TraversalStrategy.

Is that even possible?

Link to StackOverflow

[porunov]

That's a good feature request and shouldn't be hard to implement if we agree on the interface itself.

Potentially, we could introduce some internal parameters that can be used in Gremlin queries.
For example:

g.V().or(
  has('Name',textContainsPrefix("ProjectA")),
  has('Topic',textContainsPrefix("ProjectA"))
  has('Desc',textContainsPrefix("ProjectA"))
).order().by(MixedIndex.score(), desc)

In this case we would probably need an optimization strategy that checks validity of such parameters usage (if the previous steps are merged into the mixed index or not) and adds metadata information to indexes usage. In all other cases we should probably raise the exception as the query becomes invalid otherwise.

However, I don't have a strong opinion here and am open to any other solutions if someone wants to contribute it somehow else.

As for returning score that's again part of the mixed index search result definition and currently not part of Vertex definition of something else.

When you query g.V().or(has(...), has(...)) the last step defines an iterator of vertices (as per Gremlin query definition) and not a mixed index result. That's because or() is a filter step and it will return same type as input (in this case V() step). As such, there is no anything like g.V().or(...).score() because there is no g.V().score().

As such, to return score we should figure out where should it be returned.
In fact, JanusGraph already has score internally when ElasticSearch index is queried, but we don't utilize it outside of the direct index calls because it's not part of the element properties

janusgraph/janusgraph-es/src/main/java/org/janusgraph/diskstorage/es/rest/RestSearchHit.java

Line 36 in 02c1bcb

private Float score;

Perhaps TinkerPop community can add some input on this (i.e. semantically correct way of returning arbitrary data that's not part of the Element definition).
We could introduce something like queriedMetadata and let's say be able to access it via element.getQueriedMetadata().get("score") that will be an optional metadata that was returned when an element was queried, but it seems a bit hack-y doing this way. A better way would be an standardized agreement in TinkerPop community.

[porunov]

Btw. In Amazone Neptune they seem to use this approach:

.withSideEffect('Neptune#fts.sortBy', 'name')

We could apply similar approach regarding querying the mixed index (i.e. adding sortBy, minScore, etc.). However, I didn't find Gremlin way of returning the actual score. Perhaps, also from side effects (to not introduce unnecessary data structure inside Vertex / Edge elements).

That's again, a hack and not a standardized solution, but to standardize it we would need to reach out to Gremlin community for this.

That said, I would be OK to have it as side effects for now until standardized Gremlin solution is agreed. We could then deprecate side-effect solution.