Recombee

https://docs.recombee.com
Admin
Recombee is a Recommender as a Service platform that uses collaborative filtering and content-based...
Tokens:343,605
Snippets:2,857
Trust Score:10
Update:5 months ago
Show doc for...
Tokens:
Raw
### Basic .NET Client Example

Source: https://docs.recombee.com/net_client

This example demonstrates how to initialize the RecombeeClient, send a batch of purchase events, and retrieve item recommendations for a user. It also shows how to get the next set of recommendations.

```APIDOC
## .NET API Client Example

### Description
This example demonstrates the basic usage of the Recombee .NET client. It covers initializing the client, sending a batch of `AddPurchase` requests, and then retrieving recommendations using `RecommendItemsToUser` and `RecommendNextItems`.

### Usage
1. Initialize `RecombeeClient` with your database ID, private token, and region.
2. Create a list of `Request` objects, such as `AddPurchase`.
3. Send the requests using `client.Send(new Batch(requests))` for efficiency.
4. Retrieve recommendations using `client.Send(new RecommendItemsToUser(userId, count))`.
5. Fetch subsequent recommendations using `client.Send(new RecommendNextItems(recommId, count))`.

### Code Example
```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using Recombee.ApiClient;
using Recombee.ApiClient.ApiRequests;
using Recombee.ApiClient.Bindings;
using Recombee.ApiClient.Util;

public class BasicExample
{
    static int Main(string[] args)
    {
        RecombeeClient client = new RecombeeClient("--your-database-id--", "--your-db-private-token--", region: Region.UsWest);

        try
        {
            const int NUM = 100;
            var userIds = Enumerable.Range(0, NUM).Select(i => String.Format("user-{0}", i));
            var itemIds = Enumerable.Range(0, NUM).Select(i => String.Format("item-{0}", i));
            // Generate some random purchases of items by users
            const double PROBABILITY_PURCHASED = 0.1;
            Random r = new Random();
            var purchases = new List<Request>();

            foreach(var userId in userIds) {
                purchases.AddRange(
                    itemIds.Where(_ => r.NextDouble() < PROBABILITY_PURCHASED)
                          .Select(itemId =>
                                    new AddPurchase(userId, itemId, cascadeCreate: true) // Use cascadeCreate parameter to create
                          )                                                             // the yet non-existing users and items
                );
            }

            Console.WriteLine("Send purchases");
            client.Send(new Batch(purchases)); //Use Batch for faster processing of larger data

            // Recommend 5 items for user 'user-25'
            RecommendationResponse recommendationResponse = client.Send(new RecommendItemsToUser("user-25", 5));
            Console.WriteLine("Recommended items:");
            foreach(Recommendation rec in recommendationResponse.Recomms) Console.WriteLine(rec.Id);

            // User scrolled down - get next 3 recommended items
            recommendationResponse = client.Send(new RecommendNextItems(recommendationResponse.RecommId, 3));
            Console.WriteLine("Next recommended items:");
            foreach(Recommendation rec in recommendationResponse.Recomms) Console.WriteLine(rec.Id);

        }
        catch(ApiException e)
        {
        Console.WriteLine(e.ToString());
        // Use fallback
        }

        return 0;
    }
}
```
```

--------------------------------

### Basic Grid Widget Setup

Source: https://docs.recombee.com/widget-sdks/grid-widget-react

This example demonstrates the basic setup of the GridWidget using the DefaultItem component for rendering recommendations. Ensure `returnProperties: true` is set in your API request and use CSS for grid layout.

```typescript
import {
  GridWidget,
  DefaultItem,
  ItemImage,
  addRecommIdQueryParam,
} from "@recombee/grid-widget-react";
import "@recombee/grid-widget-react/dist/styles.css";

export default () => {
  return (
    <div className="@container">
      <GridWidget
        apiClient={apiClient}
        createRequest={createRequest}
        contentClassName="grid-cols-[repeat(1,1fr)] grid-rows-[repeat(4,1fr)] gap-2 @lg:grid-cols-[repeat(2,1fr)] @lg:grid-rows-[repeat(3,1fr)] @xl:grid-cols-[repeat(4,1fr)] @xl:grid-rows-[repeat(2,1fr)]"
        itemWrapperClassName="min-h-[260px]"
        ItemComponent={(props) => (
          <DefaultItem
            href={addRecommIdQueryParam(
              props.result?.values?.link,
              props.state.recommId,
            )}
            image={
              <ItemImage
                src={`${props.result?.values?.images?.[0]}`}
                width={600}
                height={400}
              />
            }
            labelContent={`${props.result?.values?.genres?.join(", ")}`}
            title={`${props.result?.values?.title}`}
            highlightedContent={`${props.result?.values?.year}`}
          />
        )}
      />
    </div>
  );
};

```

--------------------------------

### Python API Client Example

Source: https://docs.recombee.com/python_client

This example demonstrates how to initialize the RecombeeClient, add purchase data in batches, and retrieve item recommendations for a user. It also shows how to get the next set of recommendations after a user interaction.

```APIDOC
## Python API Client Usage Example

### Description
This code snippet shows how to use the Recombee Python client to send batch requests for adding purchases and to retrieve item recommendations for a user. It includes error handling for API exceptions.

### Code
```python
from recombee_api_client.api_client import RecombeeClient, Region
from recombee_api_client.exceptions import APIException
from recombee_api_client.api_requests import *
import random

# Initialize the client with your database ID and private token
client = RecombeeClient('--your-database-id--', '--your-db-private-token--', region=Region.US_WEST)

# Generate some random purchases of items by users
PROBABILITY_PURCHASED = 0.1
NUM = 100
purchase_requests = []

for user_id in ["user-%s" % i for i in range(NUM) ]:
  for item_id in ["item-%s" % i for i in range(NUM) ]:
    if random.random() < PROBABILITY_PURCHASED:
      # Create an AddPurchase request
      request = AddPurchase(user_id, item_id, cascade_create=True)
      purchase_requests.append(request)

try:
    # Send the data to Recombee using Batch for faster processing
    print('Send purchases')
    client.send(Batch(purchase_requests))

    # Get recommendations for a specific user
    response = client.send(RecommendItemsToUser('user-25', 5))
    print("Recommended items: %s" % response)

    # Get the next set of recommended items after user interaction (e.g., scrolling)
    response = client.send(RecommendNextItems(response['recommId'], 3))
    print("Next recommended items: %s" % response)

except APIException as e:
    # Handle any API exceptions
    print(e)
```

### Usage Notes
- Replace `'--your-database-id--'` and `'--your-db-private-token--'` with your actual Recombee database credentials.
- The `Region` can be adjusted based on your database's location.
- `AddPurchase` is used to log user-item interactions. `cascade_create=True` will create the user or item if they do not exist.
- `RecommendItemsToUser` fetches a list of recommended items for a given user.
- `RecommendNextItems` is used to fetch subsequent recommendations, often used for pagination or when a user interacts with the current recommendations.
```

--------------------------------

### PHP API Client Example

Source: https://docs.recombee.com/php_client

This example demonstrates how to initialize the Recombee PHP client, send a batch of purchase requests, and retrieve recommendations for a user. It also shows how to get the next set of recommendations after a user scrolls.

```APIDOC
## PHP API Client Example

### Description
This example demonstrates how to initialize the Recombee PHP client, send a batch of purchase requests, and retrieve recommendations for a user. It also shows how to get the next set of recommendations after a user scrolls.

### Usage

```php
use Recombee\RecommApi\Client;
use Recombee\RecommApi\Requests as Reqs;
use Recombee\RecommApi\Exceptions as Ex;

$client = new Client('--your-database-id--', '--your-db-private-token--', ['region' => 'us-west']);

const NUM = 100;
const PROBABILITY_PURCHASED = 0.1;

try {
    // Generate some random purchases of items by users
    $purchase_requests = array();
    for($i = 0; $i < NUM; $i++) {
        for($j = 0; $j < NUM; $j++) {
            if(mt_rand() / mt_getrandmax() < PROBABILITY_PURCHASED) {
                $request = new Reqs\AddPurchase("user-" . $i, "item-" . $j, ['cascadeCreate' => true]);
                array_push($purchase_requests, $request);
            }
        }
    }
    echo "Send purchases\n";
    $res = $client->send(new Reqs\Batch($purchase_requests)); //Use Batch for faster processing of larger data

    // Get 5 recommendations for user 'user-25'
    $response = $client->send(new Reqs\RecommendItemsToUser('user-25', 5));
    echo 'Recommended items: ' . json_encode($response, JSON_PRETTY_PRINT) . "\n";
    
    // User scrolled down - get next 3 recommended items
    $response = $client->send(new Reqs\RecommendNextItems($response['recommId'], 3));
    echo 'Next recommended items: ' . json_encode($response, JSON_PRETTY_PRINT) . "\n";

} catch(Ex\ApiException $e) {
    //use fallback
}

```

### Initialization

```php
$client = new Client('--your-database-id--', '--your-db-private-token--', ['region' => 'us-west']);
```

### Sending Batch Requests

```php
$purchase_requests = array();
// ... populate $purchase_requests with Reqs\AddPurchase objects ...
$res = $client->send(new Reqs\Batch($purchase_requests));
```

### Getting Recommendations

```php
$response = $client->send(new Reqs\RecommendItemsToUser('user-25', 5));
```

### Getting Next Recommendations

```php
$response = $client->send(new Reqs\RecommendNextItems($response['recommId'], 3));
```

### Error Handling

```php
catch(Ex\ApiException $e) {
    //use fallback
}
```
```

--------------------------------

### Example Response with All Properties

Source: https://docs.recombee.com/openapi.yaml

This is an example response when `returnProperties=true` is set, showing all properties for recommended items.

```json
{
  "recommId": "ce52ada4-e4d9-4885-943c-407db2dee837",
  "recomms": 
    [
      {
        "id": "tv-178",
        "values": {
          "description": "4K TV with 3D feature",
          "categories":   ["Electronics", "Televisions"],
          "price": 342,
          "url": "myshop.com/tv-178"
        }
      },
      {
        "id": "mixer-42",
        "values": {
          "description": "Stainless Steel Mixer",
          "categories":   ["Home & Kitchen"],
          "price": 39,
          "url": "myshop.com/mixer-42"
        }
      }
    ],
   "numberNextRecommsCalls": 0
}
```

--------------------------------

### Batch Request Example

Source: https://docs.recombee.com/api.html

An example demonstrating how to send three individual requests (setting item values, adding a detail view, and getting user recommendations) in a single batch.

```APIDOC
## Batch Request

### Description
Allows executing multiple API requests in a single HTTP call. The body of a batch request is a JSON object containing a `requests` key, which holds an array of individual request objects.

### Method
POST

### Endpoint
/

### Parameters
#### Request Body
- **requests** (array) - Required - An array of request objects.
  - Each request object contains:
    - **method** (string) - Required - HTTP method (PUT, POST, GET, DELETE, case insensitive).
    - **path** (string) - Required - Path of the request from the root of the database.
    - **params** (object) - Optional - Parameters for the request.

### Request Example
```json
{
  "requests": [
    {
      "method": "POST",
      "path": "/items/item-24",
      "params": {
        "product_description": "4K TV with 3D feature",
        "categories":   ["Electronics", "Televisions"],
        "price_usd": 342,
        "!cascadeCreate": true
      }
    },
    {
      "method": "POST",
      "path": "/detailviews/",
      "params": {
        "userId": "user-123",
        "itemId": "item-x",
        "timestamp": 1404727253,
        "cascadeCreate": true
      }
    },
    {
      "method": "GET",
      "path": "/recomms/users/user-123/items/",
      "params": {
        "count": 3
      }
    }
  ]
}
```

### Response
#### Success Response (200)
- The response is a JSON array where each element corresponds to the result of a request in the batch, in the same order.
```

--------------------------------

### Ruby SDK for Interactions and Recommendations

Source: https://docs.recombee.com/tutorial

This example demonstrates sending interactions and fetching recommendations using the Recombee Ruby SDK. Ensure the gem is installed.

```ruby
require 'recombee_api_client'
require 'recombee_api_client/exceptions'

# Your Recombee credentials
client = RecombeeApiClient::RecombeeClient.new('your-case-id', 'your-private-token')

begin
  # Example: Sending an interaction (e.g., item viewed)
  client.send_(RecombeeApiClient::SetItemView.new('user-123', 'item-abc').set_timestamp(1391375555.0))
  puts 'Interaction sent successfully.'

  # Example: Getting recommendations for a user
  recommendations = client.send_(RecombeeApiClient::RecommendItemsToUser.new('user-123', 5).set_return_abstain(true))
  puts "Recommendations: #{recommendations}"

rescue RecombeeApiClient::ApiException => e
  puts "Error: #{e.message}"
end

```

--------------------------------

### Example Response with Included Properties

Source: https://docs.recombee.com/openapi.yaml

This is an example response when `returnProperties=true` and `includedProperties=description,price` are set, showing only specified properties for recommended items.

```json
{
  "recommId": "a86ee8d5-cd8e-46d1-886c-8b3771d0520b",
  "recomms":
    [
      {
        "id": "tv-178",
        "values": {
          "description": "4K TV with 3D feature",
          "price": 342
        }
      },
      {
        "id": "mixer-42",
        "values": {
          "description": "Stainless Steel Mixer",
          "price": 39
        }
      }
    ],
  "numberNextRecommsCalls": 0
}
```

--------------------------------

### Get User Property Info Response Example

Source: https://docs.recombee.com/api.html

Example JSON response when successfully retrieving user property information.

```json
{
  "name": "country",
  "type": "string"
}
```

--------------------------------

### Example Response with Properties

Source: https://docs.recombee.com/api.html

This example demonstrates the structure of a response when `returnProperties=true` is set, including item IDs and their associated property values.

```json
{
  "recommId": "0c6189e7-dc1a-429a-b613-192696309361",
  "recomms":
    [
      {
        "id": "tv-178",
        "values": {
          "description": "4K TV with 3D feature",
          "categories":   ["Electronics", "Televisions"],
          "price": 342,
          "url": "myshop.com/tv-178"
        }
      },
      {
        "id": "mixer-42",
        "values": {
          "description": "Stainless Steel Mixer",
          "categories":   ["Home & Kitchen"],
          "price": 39,
          "url": "myshop.com/mixer-42"
        }
      }
    ],
  "numberNextRecommsCalls": 0
}


```

--------------------------------

### Java API Client Usage Example

Source: https://docs.recombee.com/java_client

This example demonstrates how to initialize the RecombeeClient, send batch requests for adding purchases, and retrieve item recommendations for a user. It also shows how to fetch subsequent recommendations.

```APIDOC
## Java API Client Usage Example

### Description
This example demonstrates how to initialize the RecombeeClient, send batch requests for adding purchases, and retrieve item recommendations for a user. It also shows how to fetch subsequent recommendations.

### Initialization
```java
RecombeeClient client = new RecombeeClient("--your-database-id--", "--your-db-private-token--").setRegion(Region.US_WEST);
```

### Adding Purchases (Batch)
```java
final int NUM = 100;
final double PROBABILITY_PURCHASED = 0.1;
Random r = new Random();
ArrayList<Request> addPurchaseRequests = new ArrayList<Request>();
for (int i = 0; i < NUM; i++)
    for (int j = 0; j < NUM; j++)
        if (r.nextDouble() < PROBABILITY_PURCHASED) {
            AddPurchase request = new AddPurchase(String.format("user-%s", i),String.format("item-%s", j))
                                        .setCascadeCreate(true);
            addPurchaseRequests.add(request);
        }

client.send(new Batch(addPurchaseRequests));
```

### Getting Recommendations
```java
RecommendationResponse recommendationResponse = client.send(new RecommendItemsToUser("user-25", 5));
for(Recommendation rec: recommendationResponse) System.out.println(rec.getId());
```

### Getting Next Recommendations
```java
recommendationResponse = client.send(new RecommendNextItems(recommendationResponse.getRecommId(), 3));
for(Recommendation rec: recommendationResponse) System.out.println(rec.getId());
```

### Error Handling
```java
} catch (ApiException e) {
    e.printStackTrace();
    //use fallback
}
```
```

--------------------------------

### List Items with Included Properties Example

Source: https://docs.recombee.com/openapi.yaml

Example response when listing items and specifying which properties to include. Only the `description` and `price` are returned for each item.

```json
[
  {
    "itemId": "tv-178",
    "description": "4K TV with 3D feature",
    "price": 342
  },
  {
    "itemId": "mixer-42",
    "description": "Stainless Steel Mixer",
    "price": 39
  }
]
```

--------------------------------

### Node.js API Client Example

Source: https://docs.recombee.com/node_client

This example demonstrates how to initialize the Recombee Node.js client, add purchase events in batches, and then retrieve recommendations for a user. It also shows how to fetch subsequent recommendations.

```APIDOC
## Node.js API Client Usage

### Description
This code snippet illustrates the basic usage of the Recombee Node.js client. It covers initializing the client with your database credentials, sending a batch of `AddPurchase` requests, and then making calls to `RecommendItemsToUser` and `RecommendNextItems`.

### Initialization
```javascript
var recombee = require('recombee-api-client');
var rqs = recombee.requests;

var client = new recombee.ApiClient('--your-database-id--', '--your-db-private-token--', {region: 'us-west'});
```

### Adding Purchases in Batch
```javascript
// Prepare some userIDs and itemIDs
const NUM = 100;
var userIds = Array.apply(0, Array(NUM)).map((_, i) => {
  return `user-${i}`;
});

var itemIds = Array.apply(0, Array(NUM)).map((_, i) => {
  return `item-${i}`;
});

// Generate some random purchases of items by users
const PROBABILITY_PURCHASED = 0.1;
var purchases = [];
userIds.forEach((userId) => {
  var purchased = itemIds.filter(() => Math.random() < PROBABILITY_PURCHASED);
  purchased.forEach((itemId) => {
    purchases.push(new rqs.AddPurchase(userId, itemId, {'cascadeCreate': true}))
  });
});

// Send the data to Recombee, use Batch for faster processing of larger data
client.send(new rqs.Batch(purchases))
```

### Getting Recommendations
```javascript
.then(() => {
  //Get 5 recommended items for user 'user-25'
  return client.send(new rqs.RecommendItemsToUser('user-25', 5));
})
.then((response) => {
  console.log("Recommended items for user-25: %j", response.recomms);

  // User scrolled down - get next 3 recommended items
  return client.send(new rqs.RecommendNextItems(response.recommId, 3));
})
.then((response) => {
  console.log("Next recommended items for user-25: %j", response.recomms);
})
.catch((error) => {
  console.error(error);
  // Use fallback
});
```
```

--------------------------------

### List Items with Properties Example

Source: https://docs.recombee.com/openapi.yaml

Example response when listing items and requesting their properties. Each item includes its ID and specified property values.

```json
[
  {
    "itemId": "tv-178",
    "description": "4K TV with 3D feature",
    "categories":   ["Electronics", "Televisions"],
    "price": 342,
    "url": "myshop.com/tv-178"
  },
  {
    "itemId": "mixer-42",
    "description": "Stainless Steel Mixer",
    "categories":   ["Home & Kitchen"],
    "price": 39,
    "url": "myshop.com/mixer-42"
  }
]
```

--------------------------------

### Example Response with ReQL Evaluations

Source: https://docs.recombee.com/openapi.yaml

Shows an example response that includes the results of evaluated ReQL expressions for each recommended item.

```json
{
  "recommId": "ce52ada4-e4d9-4885-943c-407db2dee837",
  "recomms": 
    [
      {
        "id": "restaurant-178",
        "reqlEvaluations": {
          "isInUsersCity": true,
          "distanceToUser": 5200.2
        }
      },
      {
        "id": "bar-42",
        "reqlEvaluations": {
          "isInUsersCity": false,
          "distanceToUser": 2516.0
        }
      }
    ],
   "numberNextRecommsCalls": 0
}
```

--------------------------------

### List Users Example Response

Source: https://docs.recombee.com/openapi.yaml

Example JSON response when requesting user properties.

```json
[
  {
    "userId": "user-81",
    "country": "US",
    "sex": "M"
  },
  {
    "userId": "user-314",
    "country": "CAN",
    "sex": "F"
  }
]
```

--------------------------------

### Example Response with returnProperties=true

Source: https://docs.recombee.com/api.html

This example demonstrates the structure of a response when `returnProperties` is set to `true`, including user IDs and their associated property values.

```json
{
    "recommId": "9cb9c55d-50ba-4478-84fd-ab456136156e",
    "recomms": 
      [
        {
          "id": "user-17",
          "values": {
            "country": "US",
            "sex": "F"
          }
        },
        {
          "id": "user-2",
          "values": {
            "country": "CAN",
            "sex": "M"
          }
        }
      ],
    "numberNextRecommsCalls": 0
  }
```

--------------------------------

### Example Response with ReQL Evaluations

Source: https://docs.recombee.com/openapi.yaml

This example shows a response that includes `reqlEvaluations` for each recommended item, displaying the results of the computed ReQL expressions.

```json
{
  "recommId": "ce52ada4-e4d9-4885-943c-407db2dee837",
  "recomms": 
    [
      {
        "id": "restaurant-178",
        "reqlEvaluations": {
          "isInUsersCity": true,
          "distanceToUser": 5200.2
        }
      },
      {
        "id": "bar-42",
        "reqlEvaluations": {
          "isInUsersCity": false,
          "distanceToUser": 2516.0
        }
      }
    ]
```

--------------------------------

### List Users Basic Example Response

Source: https://docs.recombee.com/openapi.yaml

Basic example response containing only user IDs.

```json
[
  "user-1",
  "user-2",
  "user-3"
]
```

--------------------------------

### Ruby API Client Example

Source: https://docs.recombee.com/ruby_client

This example demonstrates how to initialize the Recombee client, add purchase data in batches, and retrieve item recommendations for a user. It also shows how to handle potential API errors.

```APIDOC
## Ruby API Client Example

### Description
This example demonstrates how to initialize the Recombee client, add purchase data in batches, and retrieve item recommendations for a user. It also shows how to handle potential API errors.

### Usage

1. **Initialization**: Create a `RecombeeClient` instance with your database ID, private token, and region.
2. **Data Preparation**: Generate user and item data, and create `AddPurchase` objects for each transaction. Use `cascadeCreate: true` to automatically create non-existent users and items.
3. **Batch Sending**: Send multiple `AddPurchase` operations efficiently using `Batch.new`.
4. **Recommendations**: Use `RecommendItemsToUser` to get initial recommendations and `RecommendNextItems` to fetch subsequent recommendations based on a `recommId`.
5. **Error Handling**: Wrap API calls in a `begin...rescue APIError` block to gracefully handle any issues.

### Code Example
```ruby
require 'recombee_api_client'
include RecombeeApiClient

client = RecombeeClient.new('--your-database-id--', '--your-db-private-token--', {:region => 'us-west'})

# Generate some random purchases of items by users
NUM = 100
PROBABILITY_PURCHASED = 0.1

users = (1..NUM).map { |i| "user-" + i.to_s }
items = (1..NUM).map { |i| "item-" + i.to_s }
purchases = []

users.each do |user_id|
  purchased = items.select { |_| rand(0.0..1.0) < PROBABILITY_PURCHASED }
  purchased.each { |item_id| purchases.push(

                AddPurchase.new(user_id, item_id,'cascadeCreate' => true)
                                                  # Use cascadeCreate to create the
                                                  # yet non-existing users and items
                )}

end

begin
  # Send the data to Recombee, use Batch for faster processing of larger data
  client.send(Batch.new(purchases))

  # Get recommendations for user 'user-25'
  response = client.send(RecommendItemsToUser.new('user-25', 5))
  puts "Recommended items for user-25: " + response.to_s

  # User scrolled down - get next 3 recommended items
  response = client.send(RecommendNextItems.new(response['recommId'], 3))
  puts "Next recommended items for user-25: " + response.to_s

rescue APIError => e
  puts e
  # Use fallback
end
```

### Key Classes Used
- `RecombeeClient`: The main client for interacting with the Recombee API.
- `AddPurchase`: Represents a user's purchase of an item.
- `Batch`: Used to send multiple requests in a single API call for efficiency.
- `RecommendItemsToUser`: Request to get item recommendations for a specific user.
- `RecommendNextItems`: Request to get the next set of recommendations based on a previous recommendation ID.
- `APIError`: Exception class for handling API-related errors.
```

--------------------------------

### Multi-Type Search Results Example

Source: https://docs.recombee.com/widget-sdks/quick-search-widget-js

Example demonstrating how to configure the Quick Search Widget to display multiple types of search results (e.g., items and categories/brands) by using a Batch request with `SearchItems` and `SearchItemSegments`.

```APIDOC
## Multi-Type Search Results

### Description
This example shows how to configure the Quick Search Widget to display multiple types of results, such as items and categories or brands, by sending search requests together in a single Batch request.

### Usage
```typescript
import {
  QuickSearchWidget,
  addRecommIdQueryParam,
  DefaultInput,
  DefaultItem,
  ItemImage,
  SearchIcon,
  CloseIcon,
  html,
  Batch,
  SearchItems,
  SearchItemSegments,
} from "@recombee/quick-search-widget-js";

import "@recombee/quick-search-widget-js/dist/styles.css";

const createRequest = ({ searchQuery }) => {
  return new Batch(
    [
      new SearchItems("userId", searchQuery, 5, {
        scenario: "search",
        cascadeCreate: true,
        returnProperties: true,
      }),
      new SearchItemSegments("userId", searchQuery, 5, {
        scenario: "search-brands",
        cascadeCreate: true,
      }),
    ],
    {
      distinctRecomms: true,
    },
  );
};

QuickSearchWidget({
  container: "#widget-root",
  apiClient: apiClient,
  createRequest: createRequest,
  minSearchCharactersCount: 3,
  primaryResultsIndex: 0,
  desktopMediaQuery: "(min-width: 1000px)",
  popoverClassName: "lg:w-[--qs-input-width] lg:flex lg:justify-center",

  InputComponent: (props) =>
    html`<form className="flex w-[400px] text-[#374040]">
      <${DefaultInput}
        state=${props.state}
        inputProps=${{
          placeholder: `Search for "table"...`,
        }}
      />
    </form>`,

  TriggerComponent: (props) =>
    html`<button
      ...${props.state.triggerProps}
      className="flex size-[38px] items-center justify-center rounded-sm bg-[#3bc4a1] text-white"
    >
      <${SearchIcon} />
    </button>`,

  DropdownComponent: (props) =>
    html`<div
      className="mt-1 flex h-full max-h-full min-h-0 flex-col rounded-sm bg-white text-[#374040] shadow-2xl lg:h-auto lg:max-w-[900px] lg:min-w-[600px]"
    >
      ${!props.state.isDesktop &&
      html`<form className="flex items-center gap-2 p-2">
        <div className="flex-grow">
          <${DefaultInput}
            state=${props.state}
            inputProps=${{
              placeholder: `Search for "table"...`,
            }}
          />
        </div>
        <button
          ...${props.state.closeButtonProps}
          className="flex size-[38px] items-center justify-center"
        >
          <${CloseIcon} />
        </button>
      </form>`}
      <div className="flex">
        <div className="flex min-h-0 flex-col">
          <div className="px-4 py-4 pb-2 text-sm font-semibold text-[#3f91ff]">
            Segments
          </div>
          <div className="overflow-auto p-2">
            ${props.state.items(1).map(
              (item) =>
                html`<a
                  key=${item.key}
                  href=${addRecommIdQueryParam(
                    item.values?.link,
                    item.recommId,
                  )}
                  ...${item.itemProps}
                  className="flex items-center gap-2 rounded-sm p-2 text-nowrap outline-hidden hover:bg-[#f7f7f7] focus:bg-[#f7f7f7]"
                  ><div className="flex-grow">
                    <div className="font-semibold">${item.id}</div>
                  </div></a
                >`,
            )}
          </div>
        </div>
        <div className="flex min-h-0 min-w-0 flex-grow flex-col">
          <div className="px-4 py-4 pb-2 text-sm font-semibold text-[#3f91ff]">
            Results
          </div>
          <div className="overflow-y-auto p-2">
            ${props.state
              .items(0)
              .map(
                (item) =>
                  html`<${DefaultItem}
                    key=${item.key}
                    href=${addRecommIdQueryParam(
                      item.values?.link,
                      item.recommId,
                    )}
                    image=${html`<${ItemImage}
                      className="size-16 overflow-hidden rounded-lg"
                      src=${`${item.values?.image}`}
                      width=${600}
                      height=${400}
                    />`}
                    primaryContent=${item.values?.product_title}
                    secondaryContent=${item.values?.category_top}
                    highlightedContent=${`USD ${item.values?.price}`}
                    ...${item.itemProps}
                  />`,
              )}
          </div>
        </div>
      </div>
    </div>`,
});
```
```

--------------------------------

### Install JavaScript API Client

Source: https://docs.recombee.com/js_client

Instructions for installing the Recombee JavaScript API Client using either a <script> tag or package managers like npm, yarn, pnpm, or bun.

```APIDOC
## Install JavaScript API Client

There are two ways to include the library in your project:

**1. `<script>` tag:**

You can add the following script tag to your HTML file (the content is served by jsDelivr):

```html
<script src="https://cdn.jsdelivr.net/npm/recombee-js-api-client@6.2.1/dist/recombee-api-client.min.js"></script>
```

If you require, you can download `recombee-api-client.min.js` and host it on your site or CDN.

```html
<script src="path/to/recombee-api-client.min.js"></script>
```

After this script is included, you can access the API Client using the global `recombee` object.

Alternatively, if you want to use the library in ESM code, you can import `recombee-api-client.min.mjs` as follows:

```html
<script type="module">
	import recombee from 'https://cdn.jsdelivr.net/npm/recombee-js-api-client@6.2.1/dist/recombee-api-client.min.mjs';
</script>
```

**2. Package managers:**

Alternatively, you can install the SDK via a package manager:

npmyarnpnpmbun

```bash
npm install recombee-js-api-client
```

```bash
yarn install recombee-js-api-client
```

```bash
pnpm install recombee-js-api-client
```

```bash
bun install recombee-js-api-client
```

Afterwards, you can import the `recombee` object as follows:

```javascript
import recombee from 'recombee-js-api-client'
// or
const recombee = require('recombee-js-api-client');
```

The library ships with types, so you should get autocompletion in your IDE out of the box. If you're using TypeScript, it should recognize these correctly and warn you about any type errors.
```

--------------------------------

### Install Grid Widget and API Client

Source: https://docs.recombee.com/widget-sdks/grid-widget-js

Install the Grid Widget JS library and the Recombee JS API client using pnpm. Ensure you specify the exact version for the widget.

```bash
pnpm add @recombee/grid-widget-js@0.2.6 recombee-js-api-client
```

--------------------------------

### Install Quick Search Widget JS

Source: https://docs.recombee.com/widget-sdks/quick-search-widget-js

Install the Quick Search Widget JS and the Recombee JS API client using pnpm. Ensure you specify the exact version for the widget.

```bash
pnpm add @recombee/quick-search-widget-js@0.2.6 recombee-js-api-client
```

--------------------------------

### Example JSON Response with Included User Properties

Source: https://docs.recombee.com/openapi.yaml

This JSON example demonstrates the response when `returnProperties=true` and `includedProperties=country` are specified. Only the 'country' property is returned for each recommended user.

```json
{
  "recommId": "b2b355dd-972a-4728-9c6b-2dc229db0678",
  "recomms":
    [
      {
        "id": "user-17",
        "values": {
          "country": "US"
        }
      },
      {
        "id": "user-2",
        "values": {
          "country": "CAN"
        }
      }
    ],
  "numberNextRecommsCalls": 0
}
```

--------------------------------

### Install Feed Widget and API Client

Source: https://docs.recombee.com/widget-sdks/feed-widget-js

Install the Feed Widget JS library and the Recombee JS API client using pnpm. Ensure you specify the exact version for the widget.

```bash
pnpm add @recombee/feed-widget-js@0.2.6 recombee-js-api-client
```

--------------------------------

### Go API Client Example

Source: https://docs.recombee.com/go_client

This example demonstrates how to initialize the Recombee Go client, send a batch of detail view interactions, and retrieve item recommendations for a user. It also shows how to fetch the next set of recommendations.

```APIDOC
## Go API Client Example

### Description
This example demonstrates how to initialize the Recombee Go client, send a batch of detail view interactions, and retrieve item recommendations for a user. It also shows how to fetch the next set of recommendations.

### Usage

1. **Initialize the client**: Use `recombee.NewRecombeeClient` with your database ID, private token, and region.
2. **Send Batch Interactions**: Create a slice of `requests.Request` objects (e.g., `AddDetailView`) and send them using `client.NewBatch(requests).Send()`.
3. **Get Recommendations**: Use `client.NewRecommendItemsToUser(userId, count)` to get initial recommendations.
4. **Get Next Recommendations**: Use `client.NewRecommendNextItems(recommId, count)` to fetch subsequent recommendations based on a previous recommendation ID.

### Code Example
```go
package main

import (
    "fmt"
    "math/rand"
    "os"

    "github.com/recombee/go-api-client/v4/recombee"
    "github.com/recombee/go-api-client/v4/recombee/requests"
)

func main() {
    client, err := recombee.NewRecombeeClient("--your-database-id--", "--your-db-private-token--", "us-west")
    if err != nil {
        fmt.Println(err)
        panic(err)
    }

    const numItemsAndUsers = 100
    const probabilityInteracted = 0.1

    var addDetailViewInteractions []requests.Request
    for i := 0; i < numItemsAndUsers; i++ {
        for j := 0; j < numItemsAndUsers; j++ {
            if rand.Float64() < probabilityInteracted {
                userId := fmt.Sprintf("user-%d", i)
                itemId := fmt.Sprintf("item-%d", j)

                request := client.NewAddDetailView(userId, itemId).SetCascadeCreate(true)
                addDetailViewInteractions = append(addDetailViewInteractions, request)
            }
        }
    }

    fmt.Println("Send all interactions in Batch")
    batchRes, err := client.NewBatch(addDetailViewInteractions).Send()
    if err != nil {
        fmt.Println(err)
        panic(err)
    }

    fmt.Println(batchRes) // Contains responses for all requests

    // Get 5 recommendations for user 'user-25'
    recommendReq := client.NewRecommendItemsToUser("user-25", 5).SetCascadeCreate(true)
    recommendRes, err := recommendReq.Send()
    if err != nil {
        fmt.Println(err)
        panic(err)
    }

    fmt.Println("Recommended items:")
    for _, rec := range recommendRes.Recomms {
        fmt.Println(rec.Id)
    }

    // User scrolled down - get next 3 recommended items
    fmt.Println("Next recommended items:")
    recommendNextRes, err := client.NewRecommendNextItems(recommendRes.RecommId, 3).Send()
    if err != nil {
        fmt.Println(err)
        panic(err)
    }

    for _, rec := range recommendNextRes.Recomms {
        fmt.Println(rec.Id)
    }
}
```
```

--------------------------------

### Get User Values Response Example

Source: https://docs.recombee.com/openapi.yaml

This is an example of a successful response when retrieving all current property values for a given user.

```json
{
  "country": "US",
  "sex": "F"
}
```

--------------------------------

### Recommend Next Items - Go

Source: https://docs.recombee.com/api.html

This Go example shows how to prepare and send a request for the next recommendations. The `recommId` and `count` are essential.

```go
request := client.NewRecommendNextItems(recommId string, count int)

result, err := request.Send() // result is of the type bindings.RecommendationResponse
```

--------------------------------

### Get Item Values Response Example

Source: https://docs.recombee.com/openapi.yaml

This is an example of a successful response when retrieving all current property values of a given item. It includes various data types like null, arrays, strings, and numbers.

```json
{
  "release-date": null,
  "tags": [
    "electronics",
    "laptops"
  ],
  "num-processors": 12,
  "description": "Very powerful laptop",
  "weight": 1.6
}
```

--------------------------------

### HTTP Request for Recommendations

Source: https://docs.recombee.com/getting_started

Example of an HTTP GET request to the Recombee API to retrieve recommendations for a user.

```http
GET /myDb/recomms/users/2c169e/items/?count=5

```

--------------------------------

### Basic .NET API Client Example

Source: https://docs.recombee.com/net_client

Demonstrates initializing the RecombeeClient, sending a batch of purchase events, and retrieving recommendations. Use cascadeCreate to automatically create users and items if they don't exist. Batch is recommended for sending large amounts of data.

```.NET
using System;
using System.Collections.Generic;
using System.Linq;
using Recombee.ApiClient;
using Recombee.ApiClient.ApiRequests;
using Recombee.ApiClient.Bindings;
using Recombee.ApiClient.Util;

public class BasicExample
{
    static int Main(string[] args)
    {
        RecombeeClient client = new RecombeeClient("--your-database-id--", "--your-db-private-token--", region: Region.UsWest);

        try
        {
            const int NUM = 100;
            var userIds = Enumerable.Range(0, NUM).Select(i => String.Format("user-{0}", i));
            var itemIds = Enumerable.Range(0, NUM).Select(i => String.Format("item-{0}", i));
            // Generate some random purchases of items by users
            const double PROBABILITY_PURCHASED = 0.1;
            Random r = new Random();
            var purchases = new List<Request>();

            foreach(var userId in userIds) {
                purchases.AddRange(
                    itemIds.Where(_ => r.NextDouble() < PROBABILITY_PURCHASED)
                          .Select(itemId =>
                                    new AddPurchase(userId, itemId, cascadeCreate: true) // Use cascadeCreate parameter to create
                          )                                                             // the yet non-existing users and items
                );
            }

            Console.WriteLine("Send purchases");
            client.Send(new Batch(purchases)); //Use Batch for faster processing of larger data

            // Recommend 5 items for user 'user-25'
            RecommendationResponse recommendationResponse = client.Send(new RecommendItemsToUser("user-25", 5));
            Console.WriteLine("Recommended items:");
            foreach(Recommendation rec in recommendationResponse.Recomms) Console.WriteLine(rec.Id);

            // User scrolled down - get next 3 recommended items
            recommendationResponse = client.Send(new RecommendNextItems(recommendationResponse.RecommId, 3));
            Console.WriteLine("Next recommended items:");
            foreach(Recommendation rec in recommendationResponse.Recomms) Console.WriteLine(rec.Id);

        }
        catch(ApiException e)
        {
        Console.WriteLine(e.ToString());
        // Use fallback
        }

        return 0;
    }
}

```

--------------------------------

### PHP API Client Example

Source: https://docs.recombee.com/php_client

Demonstrates initializing the client, sending batch purchases, and retrieving recommendations. Use cascadeCreate for new users/items. Batch requests optimize performance for large data volumes. Handles potential API exceptions.

```php
use Recombee\RecommApi\Client;
use Recombee\RecommApi\Requests as Reqs;
use Recombee\RecommApi\Exceptions as Ex;

$client = new Client('--your-database-id--', '--your-db-private-token--', ['region' => 'us-west']);

const NUM = 100;
const PROBABILITY_PURCHASED = 0.1;

try
{
    // Generate some random purchases of items by users
    $purchase_requests = array();
    for($i=0; $i < NUM; $i++) {
        for($j=0; $j < NUM; $j++) {
            if(mt_rand() / mt_getrandmax() < PROBABILITY_PURCHASED) {

                $request = new Reqs\AddPurchase("user-{$i}", "item-{$j}",
                    ['cascadeCreate' => true] // Use cascadeCreate to create the
                                              // yet non-existing users and items
                );
                array_push($purchase_requests, $request);
            }
        }
    }
    echo "Send purchases\n";
    $res = $client->send(new Reqs\Batch($purchase_requests)); //Use Batch for faster processing of larger data

    // Get 5 recommendations for user 'user-25'
    $response = $client->send(new Reqs\RecommendItemsToUser('user-25', 5));
    echo 'Recommended items: ' . json_encode($response, JSON_PRETTY_PRINT) . "\n";
    
    // User scrolled down - get next 3 recommended items
    $response = $client->send(new Reqs\RecommendNextItems($response['recommId'], 3));
    echo 'Next recommended items: ' . json_encode($response, JSON_PRETTY_PRINT) . "\n";
}
catch(Ex\ApiException $e)
{
    //use fallback
}

```

--------------------------------

### HTTP API Request for Recommendations

Source: https://docs.recombee.com/getting_started

Example HTTP GET request to the Recombee API for item recommendations. Includes essential and optional query parameters.

```http
GET /myDb/recomms/items/xyz/items/?count=10&targetUserId=2c169e&scenario=product_detail&returnProperties=true&cascadeCreate=true


```
Tokens:
Raw