Get recommendations

1
2
3
4
5
6
7
recommendations = recommend_client.get_recommendations([
    {
        indexName: "your_index_name",
        objectID: "your_object_id",
        model: "bought-together"
    }
])

1
2
3
4
5
6
7
8
9
10
11
12
13
recommendClient.getRecommendations([
  {
    indexName: 'your_index_name',
    objectID: 'your_object_id',
    model: 'bought-together'
  },
])
.then(({ results }) => {
  console.log(results);
})
.catch(err => {
  console.log(err);
});

1
2
3
4
5
6
7
8
9
recommendations = recommend_client.get_recommendations(
  [
      {
          "indexName": "your_index_name",
          "objectID": "your_object_id",
          "model": "bought-together",
      },
  ]
);

1
2
3
4
5
6
7
8
let options = RecommendationsOptions(indexName: "IndexName",
                                     model: .boughtTogether,
                                     objectID: "B018APC4LE")
  recommendClient.getRecommendations(options: [options]) { result in 
    if case .success(let response) = result {
      print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
val request = RecommendationsQuery(
    indexName = IndexName("yourIndexName"),
    objectID = ObjectID("yourObjectID"),
    model = RecommendationModel.BoughtTogether,
)

val recommendations = recommendClient.getRecommendations(requests = listOf(request))

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
public class Product
{
    public string ObjectID { get; set; }
    public string Name { get; set; }
    public string Category { get; set; }
    public float Price { get; set; }
}

public class RecommendedProduct : Product, Algolia.Search.Models.Recommend.IRecommendHit
{
    public float Score { get; set; }
}

var requests = new List<Algolia.Search.Models.Recommend.RecommendRequest> {
  new Algolia.Search.Models.Recommend.RecommendRequest {
      IndexName = "your_index_name",
      ObjectID = "your_object_id",
      Model = "bought-together",
  }
}

var recommendations = recommendClient.GetRecommendations<RecommendedProduct>(requests);

// Asynchronous
var recommendations =
  await recommendClient.GetRecommendationsAsync<RecommendedProduct>(requests);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Product implements RecommendHit {
    String objectID;
    String name;
    Float score;

    @Nonnull
    @Override
    public Float getScore() { return score; }
    public void setScore(Float score) { this.score = score; }

    public String getObjectID() { return objectID; }
    public void setObjectID(String objectID) { this.objectID = objectID; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
  }

RecommendationsQuery query = new RecommendationsQuery("yourIndexName", "bought-together", "yourObjectID");

// Synchronous
List<RecommendationsResult<Product>> recommendations = recommendClient.getRecommendations(Arrays.asList(query), Product.class);

// Asynchronous
CompletableFuture<List<RecommendationsResult<Product>>> recommendations = recommendClient.getRecommendationsAsync(Arrays.asList(query), Product.class);

1
2
options := recommend.RecommendationsOptions{IndexName: "IndexName", ObjectID: "B018APC4LE", Model: recommend.BoughtTogether}
res, err = recommendClient.GetRecommendations([]recommend.RecommendationsOptions{options})

1
2
3
4
5
6
7
8
recommendClient.execute {
  val query = RecommendationsQuery(
    indexName = "yourIndexName",
    model = "bought-together",
    objectID = "yourObjectID",
  )
  get recommendations List(query)
}