Relewise

https://docs.relewise.com/
Admin
Relewise is a personalized search and recommendation engine platform that enables developers to...
Tokens:383,257
Snippets:2,731
Trust Score:8
Update:4 hours ago
Show doc for...
Tokens:
Raw
### Example implementation for getting a User instance

Source: https://docs.relewise.com/docs/developer/sdks/dotnet/tracking/tracking-with-dotnet.html

Shows a complete method that returns a User based on cookie consent and login status. The boolean values are for demo purposes and should reflect the user's actual consent and login state.

```csharp
private User GetUser()
{
  //"true" for demo-purposes, this should reflect the users cookie-consent choice.
  bool userHasAcceptedCookies = true;
  bool userIsLoggedIn = true;
	
  User user;
	
  if (userHasAcceptedCookies)
  {
    if (userIsLoggedIn) 
    {
      user = User.ByAuthenticatedId("PermanentId", "unique ID");
    }
    else 
    {
      user = User.ByTemporaryId("unique ID");
    }	
  }
  else
  {
    user = User.Anonymous();
  }

  return user;
}
```

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

### Example implementation for getting a User instance

Source: https://docs.relewise.com/docs/developer/sdks/php/tracking/tracking-with-php.html

Shows a complete method that returns a User based on cookie consent and login status, using the UserFactory methods.

```php
private function getUser() : User
{
  //"true" for demo-purposes, this should reflect the users cookie-consent choice.
  $userHasAcceptedCookies = true;
  $userIsLoggedIn = true;
      
  $user = Null;
      
  if ($userHasAcceptedCookies)
  {
    if ($userIsLoggedIn) 
    {
      $user = UserFactory::byAuthenticatedId("PermanentId", "unique ID");
    }
    else 
    {
      $user = UserFactory::byTemporaryId("unique ID");
    }	
  }
  else
  {
    $user = UserFactory::anonymous();
  }

  return $user;
}
```

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

### SortProducts request example in C#

Source: https://docs.relewise.com/docs/developer/sdks/dotnet/recommendations/sorting-products.html

Creates a Recommender with a dataset ID, API key, and server URL, then builds a SortProductsRequest with language, currency, a product listing page label, a user from GetUser(), and product IDs. Calls RecommendAsync to get a ProductRecommendationResponse. Requires prior setup of user handling as described in the linked UserFactory documentation.

```csharp
IRecommender recommender = new Recommender(
    new Guid("00000000-0000-0000-0000-000000000001"),
    "your API Key",
    "server-url");

string[] productIds = new[] { "p-1", "p-2", "p-3" };

SortProductsRequest request = new SortProductsRequest(
    new Language("da"),
    new Currency("DKK"),
    "Product Listing Page",
    GetUser(),
    productIds);

ProductRecommendationResponse response = await recommender.RecommendAsync(request, cancellationToken);
```

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

### Configure SimilarProducts recommendation in PHP

Source: https://docs.relewise.com/docs/developer/sdks/php/recommendations/similar-products.html

Creates a Recommender with dataset ID and API key, sets the server URL, configures SimilarProductsEvaluationSettings with significance values for various product attributes, builds a SimilarProductsRequest with language, currency, and user, and calls similarProducts. Requires a user from UserFactory and setup prerequisites from the PHP SDK landing page.

```php
$recommender = new Recommender(
    "00000000-0000-0000-0000-000000000001",
    "your API Key"
);
$recommender->serverUrl = "the server URL for the dataset";

$evaluationSettings = SimilarProductsEvaluationSettings::create()
    ->setSignificanceOfSimilaritiesInDisplayName(1.0)
    ->setSignificanceOfSimilarBrand(0.5)
    ->setSignificanceOfSimilarListPrice(0.5)
    ->setSignificanceOfSimilarSalesPrice(0.5)
    ->setSignificanceOfCommonImmediateParentCategories(1.0)
    ->setSignificanceOfCommonParentsParentCategories(0.5)
    ->setSignificanceOfCommonAncestorCategories(0.25)
    ->setSignificanceOfIdenticalProductDataValues(1.0)
    ->setSignificantProductDataFieldsFromArray(array(
        SignificantDataValue::create("StringValueDataKey", SignificantDataValueSignificantDataValueComparer::Equals, 1.0),
        SignificantDataValue::create("CollectionValueDataKey", SignificantDataValueSignificantDataValueComparer::CollectionOverlap, 1.0)
    ));

$request = SimilarProductsRequest::create(
    Language::create("en-gb"),
    Currency::create("GBP"),
    "Product Details",
    $this->getUser(),
    $evaluationSettings
)
    ->setExistingProductId(ProductAndVariantId::create("product-id", "variant-id"))
    ->setSettings(
        ProductRecommendationRequestSettings::create()
            ->setNumberOfRecommendations(10)
    );

$response = $recommender->similarProducts($request);
```

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

### Prompt to install Relewise plugin

Source: https://docs.relewise.com/docs/myrelewise/agent-gateway/agent-plugin.html

Copy and send this prompt to your AI assistant to guide installation and setup of the Relewise plugin.

```markdown
Help me install and set up the Relewise plugin using this guide:
https://docs.relewise.com/docs/myrelewise/agent-gateway/agent-plugin.html
```

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

### Install @relewise/integrations with npm

Source: https://docs.relewise.com/docs/developer/sdks/ts.html

Installs the Relewise integrations package, needed for integration examples.

```bash
npm install @relewise/integrations
```

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

### Configure SimilarProducts recommendation in Java

Source: https://docs.relewise.com/docs/developer/sdks/java/recommendations/similar-products.html

Creates a Recommender and configures SimilarProductsEvaluationSettings with significance weights for display name, brand, prices, categories, and product data fields. Builds a SimilarProductsRequest with language, currency, and product ID, then sends it to get a ProductRecommendationResponse.

```java
Recommender recommender = new Recommender(
    "00000000-0000-0000-0000-000000000001",
    "your API Key",
    "the server URL for the dataset");

SimilarProductsEvaluationSettings evaluationSettings = SimilarProductsEvaluationSettings.create()
    .setSignificanceOfSimilaritiesInDisplayName(1.0)
    .setSignificanceOfSimilarBrand(0.5)
    .setSignificanceOfSimilarListPrice(0.5)
    .setSignificanceOfSimilarSalesPrice(0.5)
    .setSignificanceOfCommonImmediateParentCategories(1.0)
    .setSignificanceOfCommonParentsParentCategories(0.5)
    .setSignificanceOfCommonAncestorCategories(0.25)
    .setSignificanceOfIdenticalProductDataValues(1.0)
    .setSignificantProductDataFields(
        SignificantDataValue.create("StringValueDataKey", SignificantDataValueSignificantDataValueComparer.Equals, 1.0, null),
        SignificantDataValue.create("CollectionValueDataKey", SignificantDataValueSignificantDataValueComparer.CollectionOverlap, 1.0, null)
    );

SimilarProductsRequest request = SimilarProductsRequest.create(
    Language.create("en-gb"),
    Currency.create("GBP"),
    "Product Details",
    getUser(),
    ProductAndVariantId.create("product-id", "variant-id"))
    .setEvaluationSettings(evaluationSettings)
    .setSettings(
        ProductRecommendationRequestSettings.create()
            .setNumberOfRecommendations(10)
    );

ProductRecommendationResponse response = recommender.recommend(request);
```

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

### Custom search page flow with Relewise JavaScript SDK

Source: https://docs.relewise.com/docs/integrations/third-party/shopify/search-configuration.html

Full example of a custom search page that reads the search term from the URL, gets the user, builds a product search builder with filters and pagination, applies the app-provided configuration, and sends the request. Replace DATASET_ID, API_KEY, and SERVER_URL with your Relewise setup values.

```javascript
const searchTerm = new URLSearchParams(window.location.search).get("q") ?? "";
const configuration = window.ShopifyRelewise.searchConfigurations.search;
const user = await window.ShopifyRelewise.getUserAsync();

const settings = {
  language: Shopify.locale,
  currency: Shopify.currency.active,
  displayedAtLocation: "Custom Search Page",
  user,
};

const searcher = new Relewise.Searcher("DATASET_ID", "API_KEY", {
  serverUrl: "SERVER_URL",
});

const productSearchBuilder = new Relewise.ProductSearchBuilder(settings)
  .setSelectedProductProperties({
    displayName: true,
    pricing: true,
    dataKeys: [`${Shopify.shop}_*`],
  })
  .setSelectedVariantProperties({
    dataKeys: [`${Shopify.shop}_ShopifyVariantId`],
  })
  .setTerm(searchTerm)
  .filters((filters) =>
    filters
      .addProductDataFilter("ShopifyDomains", (condition) =>
        condition.addContainsCondition(Shopify.shop),
      )
      .addVariantDataFilter("ShopifyDomains", (condition) =>
        condition.addContainsCondition(Shopify.shop),
      ),
  )
  .pagination((pagination) =>
    pagination
      .setPageSize(24)
      .setPage(1),
  );

if (configuration.config) {
  configuration.apply(productSearchBuilder);
}

const result = await searcher.searchProducts(productSearchBuilder.build());
```

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

### SimilarProducts recommendation request with evaluation settings

Source: https://docs.relewise.com/docs/developer/sdks/dotnet/recommendations/similar-products.html

This example shows how to configure a SimilarProducts recommendation request in C#. It sets up the recommender, user context, product reference, and evaluation settings with various significance weights and comparers for product data fields. The request is then executed asynchronously.

```csharp
IRecommender recommender = new Recommender(new Guid("DATA_SET_ID"), "API_KEY", "SERVER_URL");

// Setup for language, currency, location, and user context
Language language = new("en-gb");
Currency currency = new("GBP");
string displayedAtLocation = "Product Details";
User user = User.Anonymous();

// Product reference to compare with
ProductAndVariantId productAndVariantId = new("product-id", "variant-id");

// Initialize the evaluation settings for determining similarity
SimilarProductsEvaluationSettings evaluationSettings = new()
{
	// DisplayName similarities
	SignificanceOfSimilaritiesInDisplayName = 1.0,

	// Brand similarities
	SignificanceOfSimilarBrand = 0.5,

	// Price similarities
	SignificanceOfSimilarListPrice = 0.5,
	SignificanceOfSimilarSalesPrice = 0.5,

	// Category similarities
	SignificanceOfCommonImmediateParentCategories = 1.0,   // High impact if same immediate parent
	SignificanceOfCommonParentsParentCategories = 0.5,     // Medium impact if grandparent is the same
	SignificanceOfCommonAncestorCategories = 0.25,         // Low impact for distant shared ancestors

	// Common Data Keys
	SignificanceOfCommonProductDataKeys = 0.0,

	// Identical product data values
	SignificanceOfIdenticalProductDataValues = 1.0,

	// Add specific rules for important product data fields
	SignificantProductDataFields = [
		// Exact string match
	    new SignificantDataValue(
			key: "StringValueDataKey_1",
			comparer: SignificantDataValue.SignificantDataValueComparer.Equals,
			significance: 1.0
		),

	    // String similarity
	    new SignificantDataValue(
			key: "StringValueDataKey_2",
			comparer: SignificantDataValue.SignificantDataValueComparer.StringSimilarity,
			significance: 1.0
		),

	    // Numeric exact match
	    new SignificantDataValue(
			key: "NumberValueDataKey_1",
			comparer: SignificantDataValue.SignificantDataValueComparer.Equals,
			significance: 1.0
		),

	    // Numeric percent difference
	    new SignificantDataValue(
			key: "NumberValueDataKey_2",
			comparer: SignificantDataValue.SignificantDataValueComparer.NumericPercentDifference,
			significance: 1.0
		),

	    // Overlap in collection-type data (e.g., tags, features)
	    new SignificantDataValue(
			key: "CollectionValueDataKey_1",
			comparer: SignificantDataValue.SignificantDataValueComparer.CollectionOverlap,
			significance: 1.0
		),

	    // Presence of key
	    new SignificantDataValue(
			key: "AnyDataKey",
			comparer: SignificantDataValue.SignificantDataValueComparer.KeyExists,
			significance: 1.0
		),
	]
};

SimilarProductsRequest request = new(
	language,
	currency,
	displayedAtLocation,
	user,
	productAndVariantId)
{
	EvaluationSettings = evaluationSettings
};

ProductRecommendationResponse recommendations = await recommender.RecommendAsync(request, CancellationToken.None);
```

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

### Initialize Tracker for PHP SDK

Source: https://docs.relewise.com/docs/developer/sdks/php/product-update/delete-entity.html

Sets up the Tracker with dataset ID and API key, and configures the server URL. Required before performing any administrative actions.

```php
$tracker = new Tracker(
    "00000000-0000-0000-0000-000000000001",
    "your API Key"
);
$tracker->serverUrl = "the server URL for the dataset";
```

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

### Offset response example

Source: https://docs.relewise.com/docs/search/search-highlight.html

Example response for the Offset shape. It shows the intervals (LowerBoundInclusive and UpperBoundInclusive) where the search term was found within the datakey. The values indicate the character positions of the start and end of the matched term.

```json
"Offsets": {
    "DisplayName": [],
    "Data": [
      {
        "Key": "Description",
        "Value": [
          {
            "LowerBoundInclusive": 118,
            "UpperBoundInclusive": 123
          }
        ]
      }
    ]
  },
```

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

### Apply price filters with OrFilter in C#

Source: https://docs.relewise.com/docs/howto/free-shipping-threshold.html

C# example that creates a Recommender client, computes the missing amount to reach a free shipping threshold, builds a PurchasedWithMultipleProductsRequest, and applies ProductListPriceFilter and ProductSalesPriceFilter wrapped in an OrFilter when the missing amount is positive. Includes settings for allow fill and pricing.

```csharp
// Create the recommender client
IRecommender recommender = new Recommender(
  new Guid("DATASET_ID"),
  "API_KEY",
  "SERVER_URL");

// Compute how much value is missing to reach free shipping
decimal freeShippingThreshold = 100m;
decimal cartSubtotal = 70m;
decimal missingAmount = freeShippingThreshold - cartSubtotal;

var currency = new Currency("EUR");
var cartItems = new[]
{
  new ProductAndVariantId("PRODUCT_1", "VARIANT_1"),
  new ProductAndVariantId("PRODUCT_2", "VARIANT_2")
};

// Build the recommendation request
var request = new PurchasedWithMultipleProductsRequest(
  new Language("da-DK"),
  currency,
  "Basket page",
  User.Anonymous(),
  cartItems);

// Allow filling and include pricing in the response
request.Settings.AllowFillIfNecessaryToReachNumberOfRecommendations = true;
request.Settings.SelectedProductProperties = new SelectedProductPropertiesSettings
{
  Pricing = true
};

// Apply price filters only when there is a missing amount
if (missingAmount > 0)
{
  // Define the price window around the missing amount
  decimal minPrice = missingAmount * 0.7m;
  decimal maxPrice = missingAmount * 1.5m;
  var priceRange = new Range<decimal?>(minPrice, maxPrice);

  // Match products by list OR sales price within the range
  request.Filters.Add(new OrFilter(new Filter[]
  {
    new ProductListPriceFilter(priceRange, currency),
    new ProductSalesPriceFilter(priceRange, currency)
  }));
}

// Execute the recommendation request
ProductRecommendationResponse response = await recommender.RecommendAsync(
  request,
  CancellationToken.None);
```

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

### Install dependencies

Source: https://docs.relewise.com/docs/integrations/third-party/shopify/shopify-dev-guide.html

Installs the dependencies for the Vite project.

```sh
npm install
```

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

### Create a Recommender instance

Source: https://docs.relewise.com/docs/developer/sdks/java/recommendations/product-recommendations-with-java.html

Initializes a Recommender with dataset ID, API key, and server URL. Required before making any recommendation requests.

```java
Recommender recommender = new Recommender(
    "00000000-0000-0000-0000-000000000001",
    "your API Key",
    "the server URL for the dataset");
```

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

### Install Relewise client

Source: https://docs.relewise.com/docs/integrations/third-party/shopify/shopify-dev-guide.html

Installs the @relewise/client package for Relewise integration.

```sh
npm i @relewise/client
```

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

### Create a Recommender instance in PHP

Source: https://docs.relewise.com/docs/developer/sdks/php/recommendations/product-recommendations-with-php.html

Initializes the Relewise Recommender with a dataset ID and API key, and sets the server URL. Requires the Relewise\Recommender class.

```php
use Relewise\Recommender;
// You have to `use` the above to create a Recommender.

$recommender = new Recommender(
  "00000000-0000-0000-0000-000000000001", 
  "your API Key"
);
$recommender->serverUrl = "the server URL for the dataset";
```

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

### ProductDisabledFilter JSON example

Source: https://docs.relewise.com/docs/filters/

JSON example for the ProductDisabledFilter, which demands that products being returned are not disabled.

```json
{
  "$type": "Relewise.Client.Requests.Filters.ProductDisabledFilter, Relewise.Client",
  "TypeName": "ProductDisabledFilter",
  "Negated": false
}
```

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

### Full content update example in C#

Source: https://docs.relewise.com/docs/developer/sdks/dotnet/product-update/entity-integration.html

This example shows how to set up a Tracker and perform full content updates. It includes creating a Content object with multilingual display name and data fields, adding category paths, and sending ContentUpdate and ContentAdministrativeAction objects. The code uses an import timestamp to distinguish active and inactive entities, and the tracker automatically batches items in groups of 1,000.

```csharp
async Task Main()
{
    // Copy Dataset ID + API Key + Server URL from
    // my.relewise.com > Administration -> API Credentials
    Tracker tracker = new Tracker(new Guid("00000000-0000-0000-0000-000000000001"),
    "your API Key", "the server URL for the Dataset");
    // This is the recommended "Push" method, for importing content data into Relewise.
    await FullContentUpdates(tracker);
    // Note all methods have a synchronous as well as an asynchronous counterpart,
    // e.g. Tracker.Track / Tracker.TrackAsync
}


private Task FullContentUpdates(ITracker tracker)
{
    // Create a timestamp to distinguish active and inactive entities
    double importTimestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

    // Language can be any string and doesn't have to be a valid iso-standard.
    Language english = new Language("en");

    List<Trackable> contentUpdates = new List<Trackable>();

    // Foreach content element that needs to be imported, do the following:
    {
        // The ID should be the primary ID of the content
        Content content = new Content("Content-ID-01");

        content.DisplayName = new Multilingual(new Multilingual.Value(
            // We only set the English translation in this example
            // but more can be set by parsing more MultilingualValue
            // to the Multilingual::create method.
            english, "The English display name"));

        content.Data["ShortDescription"] = new Multilingual(new Multilingual.Value(
            // We only set the English translation in this example
            // but more can be set by parsing more MultilingualValue
            // to the Multilingual::create method.
            english, "The short English description"));
        content.CategoryPaths.Add(new CategoryPath(
            new CategoryNameAndId("23", new Multilingual(
                new Multilingual.Value(english, "Outdoor"))),
            new CategoryNameAndId("372", new Multilingual(
                new Multilingual.Value(english, "Hiking")))));

        // Important to set this timestamp to the exact same value for all content
        content.Data["ImportedAt"] = importTimestamp;
        content.Data["ReadingTimeInMinutes"] = 3;
        content.Data["News"] = true;
        content.Data["Badges"] = new string[] {
            "fun", "current season", "some other badge"};

        // Add any additional fields you would want returned from Relewise

        contentUpdates.Add(new ContentUpdate(
            content,
            kind: ContentUpdate.UpdateKind.ReplaceProvidedProperties)
        );
    }
    // Foreach content element END

    // If this is a full-import (not delta),
    // disable all non-included content elements
    {
        FilterCollection nonUpdatedContentFilter = new FilterCollection(new ContentDataFilter(
            "ImportedAt", new EqualsCondition(importTimestamp, negated: true)));
        contentUpdates.Add(new ContentAdministrativeAction(Language.Undefined,
        Currency.Undefined,
        nonUpdatedContentFilter,
        Relewise.Client.DataTypes.ContentAdministrativeAction.UpdateKind.Disable));
    }

    FilterCollection updatedContentFilter = new FilterCollection(new ContentDataFilter(
        "ImportedAt", new EqualsCondition(importTimestamp, negated: false)));
    contentUpdates.Add(new ContentAdministrativeAction(Language.Undefined,
    Currency.Undefined,
    updatedContentFilter,
    Relewise.Client.DataTypes.ContentAdministrativeAction.UpdateKind.Enable));

    // Send all content updates and actions as a single (or few) network request.
    // The client will automatically send batches of 1.000 items per network request,
    // so you can pass as many as you like to the tracker.Track / TrackAsync method.
    return tracker.TrackAsync(contentUpdates.ToArray());
}
```

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

### Install Web Components and Relewise client

Source: https://docs.relewise.com/docs/integrations/web-components/universal-search.html

Install the required npm packages: @relewise/web-components and @relewise/client.

```powershell
npm install @relewise/web-components @relewise/client
```

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

### ProductDataHasKeyFilter JSON example

Source: https://docs.relewise.com/docs/filters/

JSON example for the ProductDataHasKeyFilter, which demands that the datakey 'datakeyName' exists on the entity.

```json
{
  "$type": "Relewise.Client.Requests.Filters.ProductDataHasKeyFilter, Relewise.Client",
  "Key": "datakeyName",
  "TypeName": "ProductDataHasKeyFilter",
  "Negated": false
}
```

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

### Create IRecommender instance

Source: https://docs.relewise.com/docs/developer/sdks/dotnet/recommendations/product-recommendations-with-dotnet.html

Initializes the Relewise recommender with a dataset ID, API key, and server URL. Required before making any recommendation requests.

```csharp
IRecommender recommender = new Recommender(
  new Guid("00000000-0000-0000-0000-000000000001"), 
  "your API Key", 
	"server-url");
```

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

### Import Tracker and create instance

Source: https://docs.relewise.com/docs/developer/sdks/ts/tracking/client-side-tracking.html

Import the Tracker from @relewise/client and create a new Tracker instance with your dataset ID, API key, and server URL.

```ts
import { Tracker } from "@relewise/client";

const tracker = new Tracker(RELEWISE_DATASET_ID, RELEWISE_API_KEY, {
    serverUrl: RELEWISE_SERVER_URL,
});
```
Tokens:
Raw