mbd-studio-sdk 4.1.0 → 4.1.2

package/V1/Studio.js

@@ -158,6 +158,26 @@ export class Studio {
     }
     this._candidates.sort((a, b) => (b._ranking_score ?? -Infinity) - (a._ranking_score ?? -Infinity));
   }
+  getFeed() {
+    return this._candidates;
+  }
+  dropFeatures() {
+    for (const c of this._candidates) {
+      delete c._features;
+    }
+  }
+  dropVectors() {
+    const keys = ['text_vector', 'item_sem_embed', 'item_sem_embed2'];
+    for (const c of this._candidates) {
+      const src = c._source;
+      if (src && typeof src === 'object') {
+        for (const k of keys) delete src[k];
+      }
+    }
+  }
+  transform(fn) {
+    this._candidates = this._candidates.map(fn);
+  }
   log(string) {
     this._log(string);
   }
@@ -165,7 +185,4 @@ export class Studio {
     if (results === undefined) results = this._candidates;
     this._show(results);
   }
-  getFeed() {
-    return this._candidates;
-  }
 }

package/V1/search/filters/Filter.js

@@ -1,3 +1,18 @@
+/**
+ * Ensures the value is an array. Backend expects array for terms/match filters.
+ * - Arrays are returned as-is
+ * - Strings are converted: comma-separated strings are split; single values wrapped in array
+ */
+export function normalizeToArray(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value === 'string') {
+    return value.includes(',')
+      ? value.split(',').map((s) => s.trim()).filter(Boolean)
+      : [value];
+  }
+  return value != null ? [value] : [];
+}
+
 export class Filter {
   constructor(filterType, field, boost = null) {
     if (new.target === Filter) throw new Error('Filter is abstract and cannot be instantiated directly');

package/V1/search/filters/MatchFilter.js

@@ -1,7 +1,7 @@
-import { Filter } from './Filter.js';
+import { Filter, normalizeToArray } from './Filter.js';
 export class MatchFilter extends Filter {
   constructor(field, value, boost = null) {
     super('match', field, boost);
-    this.value = value;
+    this.value = normalizeToArray(value);
   }
 }

package/V1/search/filters/TermsFilter.js

@@ -1,7 +1,7 @@
-import { Filter } from './Filter.js';
+import { Filter, normalizeToArray } from './Filter.js';
 export class TermsFilter extends Filter {
   constructor(field, value, boost = null) {
     super('terms', field, boost);
-    this.value = value;
+    this.value = normalizeToArray(value);
   }
 }

package/index.d.ts

@@ -52,10 +52,13 @@ export interface SearchResult {
   max_score?: number;
 }
 
-export interface FrequentValuesResult {
-  [key: string]: unknown;
+export interface FrequentValueItem {
+  id: string | number;
+  count: number;
 }
 
+export type FrequentValuesResult = FrequentValueItem[];
+
 export class Search {
   lastCall: { endpoint: string; payload: unknown } | null;
   lastResult: unknown;

package/llms.txt

@@ -1,37 +1,42 @@
-# MBD Studio SDK – AI Agent Reference
+# MBD Studio SDK – Reference for AI Coding Agents
 
-## Introduction
+## Overview
 
-**What it is:** SDK for MBD Studio backend services — search, features, scoring, and ranking for personalized feeds (Polymarket, Farcaster, Zora, etc.).
+SDK for MBD Studio backend services: **search** (candidate retrieval), **features** (signals/metadata), **scoring** (ML models for relevance/reranking), and **ranking** (final ranked feed with diversity).
 
-**Entry points:**
-- `import { StudioConfig, StudioV1 } from 'mbd-studio-sdk'`
-- Main client: `new StudioV1({ config })` where `config = new StudioConfig({ apiKey })`
+## Entry Points
 
-**Typical flow:**
-1. `forUser(index, userId)` — set user for personalization
-2. `search().index(name).include()/exclude()/boost().term()|numeric()|...execute()` — get candidates
-3. `addCandidates(hits)` — attach to context
-4. `features("v1").execute()` → `addFeatures(result)` — enrich with signals
-5. `scoring().model("/scoring/...").execute()` → `addScores(result, key)` — ML reranking
-6. `ranking().sortingMethod().mix()|sortBy().diversity().execute()` → `addRanking(result)` — final ranked list
-7. `getFeed()` — get sorted candidates
+- `StudioConfig` – API config (apiKey required; commonUrl or servicesUrl for endpoints)
+- `StudioV1` – Main client. Import: `import { StudioConfig, StudioV1 } from 'mbd-studio-sdk'`
 
-**Search endpoint selection (auto):** es_query > semantic (text/vector) > boost > filter_and_sort. Call `include()`/`exclude()`/`boost()` before adding filters.
+## Typical Flow
 
-**Debug tips:** All services have `lastCall` and `lastResult`. Use `config.log`/`config.show` or pass `log`/`show` in options. Features require `forUser()` and `addCandidates()` first. Ranking needs `addFeatures()` or `addScores()` for sort fields. Semantic diversity needs `includeVectors(true)` in search.
+1. `new StudioConfig({ apiKey })` → `new StudioV1({ config })`
+2. `mbd.forUser(index, userId)` – set user for personalization (optional)
+3. `mbd.search().index("...").include()/exclude()/boost().term(...).execute()` → hits
+4. `mbd.addCandidates(hits)` – attach hits to context
+5. `mbd.features("v1").execute()` → `mbd.addFeatures(result)` – enrich with signals
+6. `mbd.scoring().model("/scoring/...").execute()` → `mbd.addScores(result, "key")` – ML scores
+7. `mbd.ranking().sortingMethod(...).mix(...).execute()` → `mbd.addRanking(result)`
+8. `mbd.getFeed()` – final ranked candidates
+
+**Tip:** Search endpoints are chosen by payload: `es_query` > `semantic` (text/vector) > `boost` > `filter_and_sort`. Call `include()`/`exclude()`/`boost()` before adding filters. `findIndex()` maps index names (e.g. `farcaster-items-v2`) to canonical keys for feature/score lookups.
 
 ---
 
 ## index.js
+
+```javascript
 import * as V1 from './V1/index.js';
 export { StudioConfig } from './StudioConfig.js';
 export const StudioV1 = V1.Studio;
+```
 
-## V1/index.js
-export { Studio } from './Studio.js';
+---
 
 ## StudioConfig.js
+
+```javascript
 const defaultBaseUrl = 'https://api.mbd.xyz/v3/studio';
 export class StudioConfig {
   constructor(options) {
@@ -47,11 +52,8 @@ export class StudioConfig {
       const services = { searchService, storiesService, featuresService, scoringService, rankingService };
       const missing = Object.entries(services).filter(([, v]) => typeof v !== 'string' || !v.trim()).map(([k]) => k);
       if (missing.length > 0) throw new Error(`StudioConfig: when using servicesUrl, all service URLs are required. Missing: ${missing.join(', ')}`);
-      this.searchService = searchService.trim().replace(/\/$/, '');
-      this.storiesService = storiesService.trim().replace(/\/$/, '');
-      this.featuresService = featuresService.trim().replace(/\/$/, '');
-      this.scoringService = scoringService.trim().replace(/\/$/, '');
-      this.rankingService = rankingService.trim().replace(/\/$/, '');
+      [this.searchService, this.storiesService, this.featuresService, this.scoringService, this.rankingService] =
+        [searchService, storiesService, featuresService, scoringService, rankingService].map((u) => u.trim().replace(/\/$/, ''));
     } else {
       this.searchService = this.storiesService = this.featuresService = this.scoringService = this.rankingService = defaultBaseUrl;
     }
@@ -60,8 +62,34 @@ export class StudioConfig {
     this.show = typeof show === 'function' ? show : console.log.bind(console);
   }
 }
+```
+
+---
+
+## V1/index.js
+
+```javascript
+export { Studio } from './Studio.js';
+```
+
+---
+
+## V1/utils/indexUtils.js
+
+```javascript
+// Maps index names to canonical base (e.g. farcaster-items-v2 → farcaster-items). Used for feature/score keys.
+export function findIndex(index) {
+  const indexOptions = ['farcaster-items', 'zora-coins', 'polymarket-items', 'polymarket-wallets'];
+  for (const option of indexOptions) if (index.startsWith(option)) return option;
+  return null;
+}
+```
+
+---
 
 ## V1/Studio.js
+
+```javascript
 import { StudioConfig } from '../StudioConfig.js';
 import { Search } from './search/Search.js';
 import { Features, sortAvailableFeatures } from './features/Features.js';
@@ -86,7 +114,8 @@ export class Studio {
   async frequentValues(index, field, size = 25) { return this.search().index(index).frequentValues(field, size); }
   addCandidates(array) { this._candidates.push(...array); }
   features(version = 'v1') {
-    const items = (this._candidates && this._candidates.length > 0) ? this._candidates.map((hit) => ({ index: hit._index, id: hit._id })) : [];
+    let items = [];
+    if (this._candidates?.length > 0) items = this._candidates.map((hit) => ({ index: hit._index, id: hit._id }));
     return new Features({ url: this._config.featuresService, apiKey: this._config.apiKey, log: this._log, show: this._show, version, items, userIndex: this._forUser?.index, userId: this._forUser?.id, origin: this._origin });
   }
   addFeatures(featuresResult) {
@@ -100,33 +129,28 @@ export class Studio {
       hit._features = hit._features ? { ...hit._features, ...hitFeatures } : hitFeatures;
       hit._scores = hit._scores ? { ...hit._scores, ...hitScores } : hitScores;
       hit._info = hit._info ? { ...hit._info, ...hitInfo } : hitInfo;
-      if (hit._features) for (const [k, v] of Object.entries(hit._features)) if (typeof v === 'number' && !Number.isNaN(v)) availableFeatures[k] = true;
-      if (hit._scores) for (const [k, v] of Object.entries(hit._scores)) if (typeof v === 'number' && !Number.isNaN(v)) availableScores[k] = true;
+      if (hit._features) for (const [key, value] of Object.entries(hit._features)) if (typeof value === 'number' && !Number.isNaN(value)) availableFeatures[key] = true;
+      if (hit._scores) for (const [key, value] of Object.entries(hit._scores)) if (typeof value === 'number' && !Number.isNaN(value)) availableScores[key] = true;
     }
     this._log(`Available features: ${sortAvailableFeatures(Object.keys(availableFeatures))}`);
     this._log(`Available scores: ${sortAvailableFeatures(Object.keys(availableScores))}`);
   }
   scoring() {
     const userId = this._forUser?.id ?? null;
-    const itemIds = Array.isArray(this._candidates) && this._candidates.length > 0 ? this._candidates.map((c) => c && c._id != null ? String(c._id) : null).filter(Boolean) : [];
+    const itemIds = Array.isArray(this._candidates) && this._candidates.length > 0 ? this._candidates.map((c) => (c?._id != null ? String(c._id) : null)).filter(Boolean) : [];
     return new Scoring({ url: this._config.scoringService, apiKey: this._config.apiKey, log: this._log, show: this._show, userId, itemIds, origin: this._origin });
   }
   addScores(scoringResult, scoringKey) {
     const rankedItemIds = scoringResult;
-    if (!this._candidates || !rankedItemIds || !Array.isArray(rankedItemIds)) return;
-    const rankToScore = {};
-    rankedItemIds.forEach((itemId, index) => { rankToScore[itemId] = 1.0 - (index / rankedItemIds.length); });
-    for (const hit of this._candidates) {
-      const hitScore = rankToScore[hit._id];
-      if (hitScore) { if (!hit._scores) hit._scores = {}; hit._scores[scoringKey] = hitScore; }
-    }
+    if (!this._candidates || !Array.isArray(rankedItemIds)) return;
+    const rankToScore = {}; rankedItemIds.forEach((itemId, i) => { rankToScore[itemId] = 1.0 - (i / rankedItemIds.length); });
+    for (const hit of this._candidates) if (rankToScore[hit._id] != null) { if (!hit._scores) hit._scores = {}; hit._scores[scoringKey] = rankToScore[hit._id]; }
   }
   ranking() { return new Ranking({ url: this._config.rankingService, apiKey: this._config.apiKey, log: this._log, show: this._show, candidates: this._candidates, origin: this._origin }); }
   addRanking(rankingResult) {
     const rankedItems = rankingResult?.items;
-    if (!this._candidates || !rankedItems || !Array.isArray(rankedItems)) return;
-    const scoreByItemId = {};
-    rankedItems.forEach(({ item_id, score }) => { scoreByItemId[item_id] = score; });
+    if (!this._candidates || !Array.isArray(rankedItems)) return;
+    const scoreByItemId = {}; rankedItems.forEach(({ item_id, score }) => { scoreByItemId[item_id] = score; });
     for (const hit of this._candidates) hit._ranking_score = scoreByItemId[hit._id];
     this._candidates.sort((a, b) => (b._ranking_score ?? -Infinity) - (a._ranking_score ?? -Infinity));
   }
@@ -134,21 +158,19 @@ export class Studio {
   show(results) { this._show(results === undefined ? this._candidates : results); }
   getFeed() { return this._candidates; }
 }
+```
 
-## index.d.ts (types summary)
-// StudioConfig: apiKey, commonUrl?, servicesUrl?, log?, show?
-// SearchHit: _index, _id, _source, _features, _scores, _info, _ranking_score
-// Search: index, size, onlyIds, includeVectors, selectFields, text, vector, esQuery, sortBy, include/exclude/boost, term/terms/numeric/date/geo/match/isNull/notNull/custom, groupBoost, termsLookup, consoleAccount, execute, frequentValues, lookup
-// Features: version, items, user, execute
-// Scoring: model, userId, itemIds, execute
-// Ranking: sortingMethod(sort|linear|mix), sortBy, weight, mix, diversity(fields|semantic), fields, horizon, lambda, limitByField, every, limit, candidates, execute
+---
 
 ## V1/search/Search.js
+
+```javascript
 import { Filter, TermFilter, TermsFilter, NumericFilter, MatchFilter, GeoFilter, DateFilter, IsNullFilter, NotNullFilter, CustomFilter, GroupBoostFilter, TermsLookupFilter, ConsoleAccountFilter } from './filters/index.js';
 
 export class Search {
-  _index = null; _es_query = null; _size = 100; _only_ids = false; _include_vector = false; _select_fields = null; _text = null; _vector = null; _sort_by = null;
-  _include = []; _exclude = []; _boost = []; _active_array = null; lastCall = null; lastResult = null;
+  _index = null; _es_query = null; _size = 100; _only_ids = false; _include_vector = false; _select_fields = null;
+  _text = null; _vector = null; _sort_by = null; _include = []; _exclude = []; _boost = [];
+  _active_array = null; lastCall = null; lastResult = null;
   constructor(options) {
     if (!options || typeof options !== 'object') throw new Error('Search: options object is required');
     const { url, apiKey, origin = 'sdk', log, show } = options;
@@ -174,7 +196,10 @@ export class Search {
     const payload = { index: this._index, origin: this._origin, feed_type: feedType, include_vector: this._include_vector, size: this._size, include: serializeFilters(this._include), exclude: serializeFilters(this._exclude) };
     if (feedType === 'boost') payload.boost = serializeFilters(this._boost);
     if (feedType === 'filter_and_sort' && this._sort_by) payload.sort_by = this._sort_by;
-    if (feedType === 'semantic') { if (typeof this._text === 'string' && this._text.length > 0) payload.text = this._text; if (Array.isArray(this._vector) && this._vector.length > 0) payload.vector = this._vector; }
+    if (feedType === 'semantic') {
+      if (typeof this._text === 'string' && this._text.length > 0) payload.text = this._text;
+      if (Array.isArray(this._vector) && this._vector.length > 0) payload.vector = this._vector;
+    }
     if (this._only_ids) payload.only_ids = true;
     if (Array.isArray(this._select_fields) && this._select_fields.length > 0) payload.select_fields = this._select_fields;
     return payload;
@@ -184,40 +209,41 @@ export class Search {
     if (this._es_query != null && (typeof this._es_query !== 'object' || Array.isArray(this._es_query))) throw new Error('Search.execute: esQuery() must be called with a plain object');
     const hasOnlyIds = this._only_ids === true, hasSelectFields = Array.isArray(this._select_fields) && this._select_fields.length > 0, hasIncludeVector = this._include_vector === true;
     if ((hasOnlyIds ? 1 : 0) + (hasSelectFields ? 1 : 0) + (hasIncludeVector ? 1 : 0) > 1) throw new Error('Search: onlyIds, selectFields, includeVectors are mutually exclusive');
-    if (this.getEndpoint() === '/search/es_query' && (this._include.length || this._exclude.length || this._boost.length)) throw new Error('Search: esQuery does not support include/exclude/boost');
-    if (this.getEndpoint() === '/search/semantic' && (this._include.length || this._exclude.length || this._boost.length)) throw new Error('Search: semantic does not support include/exclude/boost');
-    if (this.getEndpoint() === '/search/semantic' && this._sort_by) throw new Error('Search: semantic does not support sortBy');
-    if (this.getEndpoint() === '/search/boost' && this._sort_by) throw new Error('Search: boost does not support sortBy');
-    const endpoint = this.getEndpoint(), payload = this.getPayload(), url = `${this._url}${endpoint}`;
+    const endpoint = this.getEndpoint();
+    if (endpoint === '/search/es_query' && (this._include.length || this._exclude.length || this._boost.length)) throw new Error('Search: esQuery() does not support include/exclude/boost');
+    if (endpoint === '/search/semantic') {
+      if (this._include.length || this._exclude.length || this._boost.length) throw new Error('Search: semantic does not support include/exclude/boost');
+      if (this._sort_by != null) throw new Error('Search: semantic does not support sortBy()');
+    }
+    if (endpoint === '/search/boost' && this._sort_by != null) throw new Error('Search: boost does not support sortBy()');
+    const payload = this.getPayload(), url = `${this._url}${endpoint}`;
     this.log(`Sending request to ${url}`);
     const startTime = performance.now();
     const response = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this._apiKey}` }, body: JSON.stringify(payload) });
     if (!response.ok) { const text = await response.text(); throw new Error(`Search API error: ${response.status} — ${text}`); }
     const result = await response.json();
-    if (result && typeof result.error !== 'undefined' && result.error !== null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error));
+    if (result?.error != null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error));
     result.took_sdk = Math.round(performance.now() - startTime);
     this.lastCall = { endpoint, payload }; this.lastResult = result;
-    const res = result.result; if (!res) throw new Error('Search.execute: result.result is undefined');
-    return res.hits;
+    if (!result.result) throw new Error('Search.execute: result.result is undefined');
+    const res = result.result; return res.hits;
   }
   async frequentValues(field, size = 25) {
     if (!this._index || typeof this._index !== 'string' || !this._index.trim()) throw new Error('Search.frequentValues: index must be set');
+    if (typeof field !== 'string' || !field.trim()) throw new Error('Search.frequentValues: field must be non-empty');
     const n = Number(size); if (!Number.isInteger(n) || n <= 0) throw new Error('Search.frequentValues: size must be positive integer');
     const endpoint = `/search/frequent_values/${encodeURIComponent(this._index)}/${encodeURIComponent(field.trim())}?size=${n}`;
     const response = await fetch(`${this._url}${endpoint}`, { method: 'GET', headers: { Authorization: `Bearer ${this._apiKey}` } });
-    if (!response.ok) throw new Error(`Search frequentValues error: ${response.status}`);
-    const result = await response.json();
-    if (result && typeof result.error !== 'undefined' && result.error !== null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error));
-    return result;
+    if (!response.ok) throw new Error(`frequentValues error: ${response.status}`);
+    const result = await response.json(); if (result?.error != null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error)); return result;
   }
   async lookup(docId) {
     if (!this._index || typeof this._index !== 'string' || !this._index.trim()) throw new Error('Search.lookup: index must be set');
+    if (typeof docId !== 'string' || !docId.trim()) throw new Error('Search.lookup: docId must be non-empty');
     const endpoint = `/search/document/${encodeURIComponent(this._index)}/${encodeURIComponent(docId.trim())}`;
     const response = await fetch(`${this._url}${endpoint}`, { method: 'GET', headers: { Authorization: `Bearer ${this._apiKey}` } });
-    if (!response.ok) throw new Error(`Search lookup error: ${response.status}`);
-    const result = await response.json();
-    if (result && typeof result.error !== 'undefined' && result.error !== null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error));
-    return result;
+    if (!response.ok) throw new Error(`lookup error: ${response.status}`);
+    const result = await response.json(); if (result?.error != null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error)); return result;
   }
   index(selected_index) { if (typeof selected_index !== 'string' || !selected_index.trim()) throw new Error('Search.index: selected_index required'); this._index = selected_index.trim(); return this; }
   size(size) { const n = Number(size); if (!Number.isInteger(n) || n <= 0 || n >= 2000) throw new Error('Search.size: 0 < size < 2000'); this._size = n; return this; }
@@ -225,7 +251,7 @@ export class Search {
   includeVectors(value) { this._include_vector = value == null ? true : Boolean(value); return this; }
   selectFields(fields) { if (fields === null) { this._select_fields = null; return this; } if (!Array.isArray(fields)) throw new Error('Search.selectFields: array or null'); this._select_fields = fields.map((f) => (typeof f === 'string' ? f.trim() : String(f))); return this; }
   text(text) { if (typeof text !== 'string' || !text.trim()) throw new Error('Search.text: non-empty string'); this._text = text.trim(); return this; }
-  vector(vector) { if (!Array.isArray(vector)) throw new Error('Search.vector: array'); this._vector = vector; return this; }
+  vector(vector) { if (!Array.isArray(vector)) throw new Error('Search.vector: array required'); this._vector = vector; return this; }
   esQuery(rawQuery) { if (rawQuery == null || typeof rawQuery !== 'object' || Array.isArray(rawQuery)) throw new Error('Search.esQuery: plain object'); this._es_query = rawQuery; return this; }
   sortBy(field, direction = 'desc') { if (typeof field !== 'string' || !field.trim()) throw new Error('Search.sortBy: field required'); if (direction !== 'asc' && direction !== 'desc') throw new Error('Search.sortBy: asc|desc'); this._sort_by = { field: field.trim(), order: direction }; return this; }
   include() { this._active_array = this._include; return this; }
@@ -236,7 +262,7 @@ export class Search {
   filter(filterInstance) {
     this._requireActiveArray();
     if (filterInstance == null || !(filterInstance instanceof Filter)) throw new Error('Search.filter: Filter instance required');
-    if (this._active_array === this._boost && filterInstance.filter !== 'group_boost' && filterInstance.boost == null) throw new Error('Search: boost array filter needs boost');
+    if (this._active_array === this._boost && filterInstance.filter !== 'group_boost' && filterInstance.boost == null) throw new Error('Search: boost array requires non-null boost (group_boost exempt)');
     this._active_array.push(filterInstance); return this;
   }
   term(field, value, boost = null) { this._requireActiveArray(); this._requireBoostForBoostArray(boost); this._active_array.push(new TermFilter(field, value, boost)); return this; }
@@ -254,34 +280,112 @@ export class Search {
   log(string) { this._log(string); }
   show(results) { this._show(results); }
 }
+```
+
+---
 
 ## V1/search/filters/Filter.js
+
+```javascript
+export function normalizeToArray(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value === 'string') return value.includes(',') ? value.split(',').map((s) => s.trim()).filter(Boolean) : [value];
+  return value != null ? [value] : [];
+}
 export class Filter {
   constructor(filterType, field, boost = null) {
     if (new.target === Filter) throw new Error('Filter is abstract');
     this.filter = filterType; this.field = field; this.boost = boost;
   }
 }
+```
+
+---
+
+## V1/search/filters/index.js
+
+```javascript
+export { Filter } from './Filter.js';
+export { TermFilter } from './TermFilter.js';
+export { TermsFilter } from './TermsFilter.js';
+export { NumericFilter } from './NumericFilter.js';
+export { MatchFilter } from './MatchFilter.js';
+export { GeoFilter } from './GeoFilter.js';
+export { DateFilter } from './DateFilter.js';
+export { IsNullFilter } from './IsNullFilter.js';
+export { NotNullFilter } from './NotNullFilter.js';
+export { CustomFilter } from './CustomFilter.js';
+export { GroupBoostFilter } from './GroupBoostFilter.js';
+export { TermsLookupFilter } from './TermsLookupFilter.js';
+export { ConsoleAccountFilter } from './ConsoleAccountFilter.js';
+```
 
-## V1/search/filters/*Filter.js (extend Filter)
-// TermFilter(field, value, boost): super('term', field, boost); this.value = value
-// TermsFilter(field, value, boost): super('terms', field, boost); this.value = value
-// NumericFilter(field, operator, value, boost): super('numeric', field, boost); this.operator = operator; this.value = value
-// MatchFilter, GeoFilter, CustomFilter: same pattern with this.value
-// DateFilter(field, dateFrom, dateTo, boost): value = { date_from?, date_to? }; at least one required
-// IsNullFilter, NotNullFilter: no value
-// GroupBoostFilter(lookup_index, field, value, group, min_boost, max_boost, n): super('group_boost', field, null)
-// TermsLookupFilter(lookup_index, field, value, path): path = dot-notation in lookup doc (e.g. "followers.ids")
-// ConsoleAccountFilter(field, value, path): path = dot-notation in account doc
+---
+
+## V1/search/filters (implementations)
+
+```javascript
+// TermFilter.js
+import { Filter } from './Filter.js';
+export class TermFilter extends Filter { constructor(field, value, boost = null) { super('term', field, boost); this.value = value; } }
+
+// TermsFilter.js
+import { Filter, normalizeToArray } from './Filter.js';
+export class TermsFilter extends Filter { constructor(field, value, boost = null) { super('terms', field, boost); this.value = normalizeToArray(value); } }
+
+// NumericFilter.js
+import { Filter } from './Filter.js';
+export class NumericFilter extends Filter { constructor(field, operator, value, boost = null) { super('numeric', field, boost); this.operator = operator; this.value = value; } }
+
+// MatchFilter.js
+import { Filter, normalizeToArray } from './Filter.js';
+export class MatchFilter extends Filter { constructor(field, value, boost = null) { super('match', field, boost); this.value = normalizeToArray(value); } }
+
+// DateFilter.js (dateFrom or dateTo required)
+import { Filter } from './Filter.js';
+export class DateFilter extends Filter { constructor(field, dateFrom = null, dateTo = null, boost = null) { super('date', field, boost); if (dateFrom == null && dateTo == null) throw new Error('DateFilter: dateFrom or dateTo required'); const value = {}; if (dateFrom != null) value.date_from = dateFrom; if (dateTo != null) value.date_to = dateTo; this.value = value; } }
+
+// GeoFilter.js
+import { Filter } from './Filter.js';
+export class GeoFilter extends Filter { constructor(field, value, boost = null) { super('geo', field, boost); this.value = value; } }
+
+// IsNullFilter.js
+import { Filter } from './Filter.js';
+export class IsNullFilter extends Filter { constructor(field, boost = null) { super('is_null', field, boost); } }
+
+// NotNullFilter.js
+import { Filter } from './Filter.js';
+export class NotNullFilter extends Filter { constructor(field, boost = null) { super('not_null', field, boost); } }
+
+// CustomFilter.js
+import { Filter } from './Filter.js';
+export class CustomFilter extends Filter { constructor(field, value, boost = null) { super('custom', field, boost); this.value = value; } }
+
+// GroupBoostFilter.js (lookup_index, field, value, group, min_boost, max_boost, n)
+import { Filter } from './Filter.js';
+export class GroupBoostFilter extends Filter { constructor(lookup_index, field, value, group, min_boost = null, max_boost = null, n = null) { super('group_boost', field, null); this.lookup_index = lookup_index; this.value = value; this.group = group; this.min_boost = min_boost; this.max_boost = max_boost; this.n = n; } }
+
+// TermsLookupFilter.js (path: dot-notation in lookup doc, e.g. "followers.ids")
+import { Filter } from './Filter.js';
+export class TermsLookupFilter extends Filter { constructor(lookup_index, field, value, path, boost = null) { super('terms_lookup', field, boost); this.lookup_index = lookup_index; this.value = value; this.path = path; } }
+
+// ConsoleAccountFilter.js (path: dot-notation in account doc)
+import { Filter } from './Filter.js';
+export class ConsoleAccountFilter extends Filter { constructor(field, value, path, boost = null) { super('console_account', field, boost); this.value = value; this.path = path; } }
+```
+
+---
 
 ## V1/features/Features.js
-export const PREFERRED_FEATURE_COLUMNS = ['found','original_rank','sem_sim_fuzzy','sem_sim_closest','usr_primary_labels','usr_secondary_labels','usr_primary_tags','usr_secondary_tags','user_affinity_avg','user_affinity_usdc','user_affinity_count','cluster_1'..'cluster_10','sem_sim_cluster1'..'sem_sim_cluster5'];
+
+```javascript
+export const PREFERRED_FEATURE_COLUMNS = ['found', 'original_rank', 'sem_sim_fuzzy', 'sem_sim_closest', 'usr_primary_labels', 'usr_secondary_labels', 'usr_primary_tags', 'usr_secondary_tags', 'user_affinity_avg', 'user_affinity_usdc', 'user_affinity_count', 'cluster_1', 'cluster_2', 'cluster_3', 'cluster_4', 'cluster_5', 'cluster_6', 'cluster_7', 'cluster_8', 'cluster_9', 'cluster_10', 'sem_sim_cluster1', 'sem_sim_cluster2', 'sem_sim_cluster3', 'sem_sim_cluster4', 'sem_sim_cluster5'];
 export function sortAvailableFeatures(available) {
   const preferred = PREFERRED_FEATURE_COLUMNS.filter((col) => available.includes(col));
   const nonPreferred = available.filter((col) => !PREFERRED_FEATURE_COLUMNS.includes(col));
-  const regular = nonPreferred.filter((c) => !c.startsWith('AI:') && !c.startsWith('TAG:')).sort();
-  const aiColumns = nonPreferred.filter((c) => c.startsWith('AI:')).sort();
-  const tagColumns = nonPreferred.filter((c) => c.startsWith('TAG:')).sort();
+  const regular = nonPreferred.filter((col) => !col.startsWith('AI:') && !col.startsWith('TAG:')).sort();
+  const aiColumns = nonPreferred.filter((col) => col.startsWith('AI:')).sort();
+  const tagColumns = nonPreferred.filter((col) => col.startsWith('TAG:')).sort();
   return [...preferred, ...regular, ...aiColumns, ...tagColumns];
 }
 export class Features {
@@ -304,22 +408,26 @@ export class Features {
   items(items) { this._items = [...items]; return this; }
   user(index, userId) { this._user = { index, id: userId }; return this; }
   async execute() {
-    if (!this._user || !this._user.index || !this._user.id) throw new Error('Features.execute: user must be set');
-    if (!Array.isArray(this._items) || this._items.length === 0) throw new Error('Features.execute: items must be set');
+    if (!this._user?.index || !this._user?.id) throw new Error('Features.execute: user must be set');
+    if (!Array.isArray(this._items) || this._items.length === 0) throw new Error('Features.execute: items must be non-empty');
     const url = `${this._url}${this.getEndpoint()}`;
     const response = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this._apiKey}` }, body: JSON.stringify(this.getPayload()) });
     if (!response.ok) throw new Error(`Features API error: ${response.status}`);
     const result = await response.json();
-    if (result && typeof result.error !== 'undefined' && result.error !== null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error));
+    if (result?.error != null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error));
     this.lastCall = { endpoint: this.getEndpoint(), payload: this.getPayload() }; this.lastResult = result;
-    const res = result.result; if (!res) throw new Error('Features.execute: result.result undefined');
-    return res;
+    if (!result.result) throw new Error('Features.execute: result.result undefined'); return result.result;
   }
   log(string) { this._log(string); }
   show(results) { this._show(results); }
 }
+```
+
+---
 
 ## V1/scoring/Scoring.js
+
+```javascript
 export class Scoring {
   _userId = null; _itemIds = []; _modelEndpoint = null; lastCall = null; lastResult = null;
   constructor(options) {
@@ -334,31 +442,36 @@ export class Scoring {
     if (userId != null && typeof userId === 'string' && userId.trim()) this._userId = userId.trim();
     if (Array.isArray(itemIds) && itemIds.length > 0) this._itemIds = itemIds.map((id) => (typeof id === 'string' ? id : String(id)));
   }
-  getEndpoint() { if (!this._modelEndpoint || !this._modelEndpoint.trim()) throw new Error('Scoring: model(endpoint) required'); return this._modelEndpoint.startsWith('/') ? this._modelEndpoint : `/${this._modelEndpoint}`; }
+  getEndpoint() { if (!this._modelEndpoint?.trim()) throw new Error('Scoring: model(endpoint) required'); return this._modelEndpoint.startsWith('/') ? this._modelEndpoint : `/${this._modelEndpoint}`; }
   getPayload() { return { origin: this._origin, user_id: this._userId, item_ids: [...this._itemIds] }; }
   model(endpoint) { this._modelEndpoint = endpoint; return this; }
   userId(userId) { this._userId = userId; return this; }
   itemIds(itemIds) { this._itemIds = itemIds; return this; }
   async execute() {
-    if (!this._modelEndpoint || !this._modelEndpoint.trim()) throw new Error('Scoring: model required');
-    if (!this._userId || typeof this._userId !== 'string' || !this._userId.trim()) throw new Error('Scoring: user_id required');
+    if (!this._modelEndpoint?.trim()) throw new Error('Scoring: model(endpoint) required');
+    if (!this._userId?.trim()) throw new Error('Scoring: user_id required');
     if (!Array.isArray(this._itemIds) || this._itemIds.length === 0) throw new Error('Scoring: item_ids required');
     const url = `${this._url}${this.getEndpoint()}`;
     const response = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this._apiKey}` }, body: JSON.stringify(this.getPayload()) });
     if (!response.ok) throw new Error(`Scoring API error: ${response.status}`);
     const result = await response.json();
-    if (result && typeof result.error !== 'undefined' && result.error !== null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error));
+    if (result?.error != null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error));
     this.lastCall = { endpoint: this.getEndpoint(), payload: this.getPayload() }; this.lastResult = result;
-    const res = result.result; if (res === undefined) throw new Error('Scoring: result.result undefined');
-    return res;
+    if (result.result === undefined) throw new Error('Scoring: result.result undefined'); return result.result;
   }
   log(string) { this._log(string); }
   show(results) { this._show(results); }
 }
+```
+
+---
 
 ## V1/ranking/Ranking.js
+
+```javascript
 export class Ranking {
-  _candidates = []; _sortMethod = 'sort'; _sortParams = null; _diversityMethod = null; _diversityParams = null; _limitsByFieldEnabled = false; _everyN = 10; _limitRules = []; lastCall = null; lastResult = null;
+  _candidates = []; _sortMethod = 'sort'; _sortParams = null; _diversityMethod = null; _diversityParams = null;
+  _limitsByFieldEnabled = false; _everyN = 10; _limitRules = []; lastCall = null; lastResult = null;
   constructor(options) {
     if (!options || typeof options !== 'object') throw new Error('Ranking: options required');
     const { url, apiKey, candidates = [], origin = 'sdk', log, show } = options;
@@ -379,7 +492,7 @@ export class Ranking {
     }
     if (this._diversityMethod === 'fields' && this._diversityParams?.fields) this._diversityParams.fields.forEach((f) => useful.add(f));
     if (this._diversityMethod === 'semantic') needEmbedding = true;
-    if (this._limitsByFieldEnabled && this._limitRules.length > 0) this._limitRules.forEach((r) => r.field && useful.add(r.field));
+    if (this._limitsByFieldEnabled && this._limitRules.length) this._limitRules.forEach((r) => r.field && useful.add(r.field));
     return { usefulFields: useful, needEmbedding };
   }
   getPayload() {
@@ -388,7 +501,7 @@ export class Ranking {
     const items = hits.map((hit) => {
       const item = { item_id: hit._id };
       for (const key of usefulFields) { const v = hit._features?.[key] ?? hit._scores?.[key]; if (v !== undefined) item[key] = v; }
-      if (needEmbedding) { let embed = hit._source?.item_sem_embed2; if (!embed || !Array.isArray(embed)) embed = hit._source?.text_vector; if (embed) item.embed = embed; }
+      if (needEmbedding) { let embed = hit._source?.item_sem_embed2; if (!embed?.length) embed = hit._source?.text_vector; if (embed) item.embed = embed; }
       return item;
     });
     const payload = { origin: this._origin, items };
@@ -399,14 +512,14 @@ export class Ranking {
   }
   _buildSortConfig() {
     if (!this._sortParams) return undefined;
-    if (this._sortMethod === 'sort' && this._sortParams.fields?.length > 0) return { method: 'sort', params: { ...this._sortParams } };
-    if (this._sortMethod === 'linear' && Array.isArray(this._sortParams) && this._sortParams.length > 0) return { method: 'linear', params: this._sortParams.map((p) => ({ field: p.field, weight: p.weight })) };
-    if (this._sortMethod === 'mix' && Array.isArray(this._sortParams) && this._sortParams.length > 0) return { method: 'mix', params: this._sortParams.map((p) => ({ field: p.field, direction: p.direction, percentage: p.percentage })) };
+    if (this._sortMethod === 'sort' && this._sortParams.fields?.length) return { method: 'sort', params: { ...this._sortParams } };
+    if (this._sortMethod === 'linear' && Array.isArray(this._sortParams) && this._sortParams.length) return { method: 'linear', params: this._sortParams.map((p) => ({ field: p.field, weight: p.weight })) };
+    if (this._sortMethod === 'mix' && Array.isArray(this._sortParams) && this._sortParams.length) return { method: 'mix', params: this._sortParams.map((p) => ({ field: p.field, direction: p.direction, percentage: p.percentage })) };
     return undefined;
   }
   _buildDiversityConfig() {
     if (!this._diversityMethod) return undefined;
-    if (this._diversityMethod === 'fields' && this._diversityParams?.fields?.length > 0) return { method: 'fields', params: { fields: [...this._diversityParams.fields] } };
+    if (this._diversityMethod === 'fields' && this._diversityParams?.fields?.length) return { method: 'fields', params: { fields: [...this._diversityParams.fields] } };
     if (this._diversityMethod === 'semantic') return { method: 'semantic', params: { lambda: Number(this._diversityParams?.lambda ?? 0.5), horizon: Number(this._diversityParams?.horizon ?? 20) } };
     return undefined;
   }
@@ -419,66 +532,50 @@ export class Ranking {
     if (x !== 'sort' && x !== 'linear' && x !== 'mix') throw new Error('Ranking.sortingMethod: sort|linear|mix');
     this._sortMethod = x;
     if (x === 'sort') this._sortParams = { fields: [], direction: [] };
-    if (x === 'linear' || x === 'mix') this._sortParams = [];
+    if (x === 'linear') this._sortParams = [];
+    if (x === 'mix') this._sortParams = [];
     return this;
   }
   sortBy(field, direction = 'desc', field2, direction2 = 'desc') {
     if (this._sortMethod === 'linear' || this._sortMethod === 'mix') throw new Error('Ranking.sortBy: only for sortingMethod("sort")');
-    this._sortMethod = 'sort'; if (!this._sortParams || !this._sortParams.fields) this._sortParams = { fields: [], direction: [] };
-    const f = typeof field === 'string' && field.trim() ? field.trim() : null; if (!f) throw new Error('Ranking.sortBy: field required');
-    if (direction !== 'asc' && direction !== 'desc') throw new Error('Ranking.sortBy: asc|desc');
+    this._sortMethod = 'sort';
+    if (!this._sortParams?.fields) this._sortParams = { fields: [], direction: [] };
+    const f = typeof field === 'string' && field.trim() ? field.trim() : null;
+    if (!f) throw new Error('Ranking.sortBy: field required'); if (direction !== 'asc' && direction !== 'desc') throw new Error('Ranking.sortBy: asc|desc');
     this._sortParams = { fields: [f], direction: [direction] };
     if (typeof field2 === 'string' && field2.trim()) { this._sortParams.fields.push(field2.trim()); this._sortParams.direction.push(direction2 === 'asc' ? 'asc' : 'desc'); }
     return this;
   }
-  weight(field, w) { if (this._sortMethod !== 'linear') throw new Error('Ranking.weight: only for linear'); const f = typeof field === 'string' && field.trim() ? field.trim() : null; if (!f) throw new Error('Ranking.weight: field required'); if (!Array.isArray(this._sortParams)) this._sortParams = []; this._sortParams.push({ field: f, weight: Number(w) }); return this; }
-  mix(field, direction, percentage) {
-    if (this._sortMethod === 'linear') throw new Error('Ranking.mix: only for mix');
-    this._sortMethod = 'mix'; if (!Array.isArray(this._sortParams)) this._sortParams = [];
-    const f = typeof field === 'string' && field.trim() ? field.trim() : null; if (!f) throw new Error('Ranking.mix: field required');
-    if (direction !== 'asc' && direction !== 'desc') throw new Error('Ranking.mix: asc|desc');
-    this._sortParams.push({ field: f, direction, percentage: Number(percentage) || 0 }); return this;
-  }
-  diversity(method) {
-    if (method !== 'fields' && method !== 'semantic') throw new Error('Ranking.diversity: fields|semantic');
-    this._diversityMethod = method;
-    if (method === 'fields') this._diversityParams = { fields: [] };
-    if (method === 'semantic') this._diversityParams = { lambda: 0.5, horizon: 20 };
-    return this;
-  }
-  fields(arrayOrItem) {
-    if (this._diversityMethod !== 'fields') throw new Error('Ranking.fields: only for diversity("fields")');
-    if (!this._diversityParams || !Array.isArray(this._diversityParams.fields)) this._diversityParams = { fields: [] };
-    const add = (name) => { const s = typeof name === 'string' && name.trim() ? name.trim() : null; if (s && !this._diversityParams.fields.includes(s)) this._diversityParams.fields.push(s); };
-    if (Array.isArray(arrayOrItem)) arrayOrItem.forEach(add); else add(arrayOrItem);
-    return this;
-  }
-  horizon(n) { if (this._diversityMethod !== 'semantic') throw new Error('Ranking.horizon: only for semantic'); if (!this._diversityParams) this._diversityParams = { lambda: 0.5, horizon: 20 }; this._diversityParams.horizon = Number(n); return this; }
-  lambda(value) { if (this._diversityMethod !== 'semantic') throw new Error('Ranking.lambda: only for semantic'); if (!this._diversityParams) this._diversityParams = { lambda: 0.5, horizon: 20 }; this._diversityParams.lambda = Number(value); return this; }
+  weight(field, w) { if (this._sortMethod !== 'linear') throw new Error('Ranking.weight: only for sortingMethod("linear")'); const f = typeof field === 'string' && field.trim() ? field.trim() : null; if (!f) throw new Error('field required'); if (!Array.isArray(this._sortParams)) this._sortParams = []; this._sortParams.push({ field: f, weight: Number(w) }); return this; }
+  mix(field, direction, percentage) { if (this._sortMethod === 'linear') throw new Error('Ranking.mix: only for sortingMethod("mix")'); this._sortMethod = 'mix'; if (!Array.isArray(this._sortParams)) this._sortParams = []; const f = typeof field === 'string' && field.trim() ? field.trim() : null; if (!f) throw new Error('field required'); if (direction !== 'asc' && direction !== 'desc') throw new Error('direction asc|desc'); this._sortParams.push({ field: f, direction, percentage: Number(percentage) || 0 }); return this; }
+  diversity(method) { if (method !== 'fields' && method !== 'semantic') throw new Error('Ranking.diversity: fields|semantic'); this._diversityMethod = method; if (method === 'fields') this._diversityParams = { fields: [] }; if (method === 'semantic') this._diversityParams = { lambda: 0.5, horizon: 20 }; return this; }
+  fields(arrayOrItem) { if (this._diversityMethod !== 'fields') throw new Error('Ranking.fields: only for diversity("fields")'); if (!Array.isArray(this._diversityParams?.fields)) this._diversityParams = { fields: [] }; const add = (name) => { const s = typeof name === 'string' && name.trim() ? name.trim() : null; if (s && !this._diversityParams.fields.includes(s)) this._diversityParams.fields.push(s); }; Array.isArray(arrayOrItem) ? arrayOrItem.forEach(add) : add(arrayOrItem); return this; }
+  horizon(n) { if (this._diversityMethod !== 'semantic') throw new Error('Ranking.horizon: only for diversity("semantic")'); if (!this._diversityParams) this._diversityParams = { lambda: 0.5, horizon: 20 }; this._diversityParams.horizon = Number(n); return this; }
+  lambda(value) { if (this._diversityMethod !== 'semantic') throw new Error('Ranking.lambda: only for diversity("semantic")'); if (!this._diversityParams) this._diversityParams = { lambda: 0.5, horizon: 20 }; this._diversityParams.lambda = Number(value); return this; }
   limitByField() { this._limitsByFieldEnabled = true; return this; }
   every(n) { this._everyN = Number(n); return this; }
-  limit(field, max) { const f = typeof field === 'string' && field.trim() ? field.trim() : null; if (!f) throw new Error('Ranking.limit: field required'); const existing = this._limitRules.find((r) => r.field === f); if (existing) existing.limit = Number(max) || 0; else this._limitRules.push({ field: f, limit: Number(max) || 0 }); return this; }
+  limit(field, max) { const f = typeof field === 'string' && field.trim() ? field.trim() : null; if (!f) throw new Error('limit: field required'); const existing = this._limitRules.find((r) => r.field === f); if (existing) existing.limit = Number(max) || 0; else this._limitRules.push({ field: f, limit: Number(max) || 0 }); return this; }
   candidates(candidates) { this._candidates = candidates; return this; }
   async execute() {
-    if (!Array.isArray(this._candidates) || this._candidates.length === 0) throw new Error('Ranking.execute: candidates required');
-    if (!this._buildSortConfig()) throw new Error('Ranking.execute: sort config required');
-    const url = `${this._url}${this.getEndpoint()}`;
-    const response = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this._apiKey}` }, body: JSON.stringify(this.getPayload()) });
+    if (!Array.isArray(this._candidates) || this._candidates.length === 0) throw new Error('Ranking: candidates required');
+    if (!this._buildSortConfig()) throw new Error('Ranking: sort config required');
+    const url = `${this._url}${this.getEndpoint()}`, payload = this.getPayload();
+    const response = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this._apiKey}` }, body: JSON.stringify(payload) });
     if (!response.ok) throw new Error(`Ranking API error: ${response.status}`);
     const result = await response.json();
-    if (result && typeof result.error !== 'undefined' && result.error !== null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error));
-    this.lastCall = { endpoint: this.getEndpoint(), payload: this.getPayload() }; this.lastResult = result;
-    const res = result.result; if (!res) throw new Error('Ranking.execute: result undefined');
-    return res;
+    if (result?.error != null) throw new Error(typeof result.error === 'string' ? result.error : String(result.error));
+    if (!result.result) throw new Error('Ranking: result undefined'); return result.result;
   }
   log(string) { this._log(string); }
   show(results) { this._show(results); }
 }
+```
 
-## V1/utils/indexUtils.js
-/** Maps index names to canonical base (farcaster-items-v2 → farcaster-items). Used for feature/score keys. */
-export function findIndex(index) {
-  const indexOptions = ['farcaster-items', 'zora-coins', 'polymarket-items', 'polymarket-wallets'];
-  for (const option of indexOptions) if (index.startsWith(option)) return option;
-  return null;
-}
+---
+
+## Debugging Tips
+
+- **lastCall / lastResult**: `Search`, `Features`, `Scoring`, and `Ranking` expose `lastCall` (endpoint + payload) and `lastResult` for debugging failed requests.
+- **Semantic diversity**: Ranking with `diversity('semantic')` needs `item_sem_embed2` or `text_vector` on hits; ensure `includeVectors(true)` when searching if you use semantic diversity.
+- **Index canonicalization**: `addFeatures`/addScores use `findIndex(hit._index)`; if your index variant (e.g. `polymarket-items-v2`) is not in `indexOptions`, features/scores may not merge.
+- **Filter boost**: When adding to `boost()` array, all filters except `groupBoost` require a non-null `boost` argument.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mbd-studio-sdk",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "description": "SDK for Embed Recommendation Engine APIs",
   "keywords": [
     "web3",