No native build steps, pod installs, or Android linking required. Pure JavaScript/TypeScript.

Project setup

1. Copy the source/ directory into your project, e.g. as vendor/algolia/.

2. Install dependencies via the commands above, or point your package manager at the copied packages if consuming locally.

3. Configure tsconfig.json paths if importing from the vendor copy:

{
  "compilerOptions": {
    "moduleResolution": "node16",
    "paths": {
      "@algolia/client-common": ["./vendor/algolia/client-common/src"],
      "@algolia/client-search": ["./vendor/algolia/client-search/src"],
      "@algolia/client-abtesting": ["./vendor/algolia/client-abtesting/src"]
    }
  }
}

4. Set environment variables (never hard-code credentials):

ALGOLIA_APP_ID=YOUR_APP_ID
ALGOLIA_API_KEY=YOUR_API_KEY

5. The CJS entry for each package is the built dist/builds/node.cjs (e.g. abtesting/index.js points there). For local source usage, import from src/ TypeScript files directly.

Public API

algoliasearch

import { algoliasearch } from 'algoliasearch';

const client = algoliasearch(appId: string, apiKey: string): AlgoliasearchClient;

The main entry point. Returns a unified client with access to search, recommend, and analytics methods. Use this when you need search and object management together without importing multiple packages.

liteClient

import { liteClient } from 'algoliasearch/lite';

const client = liteClient(appId: string, apiKey: string): LiteClient;

A minimal client with only search and browse operations. Use this in front-end bundles where payload size matters and you do not need write or analytics operations.

abtestingClient (from @algolia/client-abtesting)

import { abtestingClient } from '@algolia/client-abtesting';

const client = abtestingClient(appId: string, apiKey: string, region?: string): AbtestingClient;

Provides full CRUD for A/B tests: addABTests, getABTest, listABTests, deleteABTest, and estimateABTest. Use when building experimentation workflows or dashboards.

Models from abtesting/model/

import type {
  ABTest,
  AddABTestsRequest,
  ABTestResponse,
  ListABTestsResponse,
  EstimateABTestRequest,
  EstimateABTestResponse,
  Variant,
  Status,
} from '@algolia/client-abtesting';

Strongly-typed request/response shapes for all A/B testing operations. Import these to type-check payloads before sending.

Working examples

Scenario - Basic search query

Search an Algolia index with the umbrella client and log the hits.

import { algoliasearch } from 'algoliasearch';

const client = algoliasearch(
  process.env.ALGOLIA_APP_ID!,
  process.env.ALGOLIA_API_KEY!
);

async function searchProducts(query: string) {
  const response = await client.search({
    requests: [{ indexName: 'products', query }],
  });
  const hits = response.results[0].hits;
  console.log(`Found ${hits.length} results for "${query}"`);
  return hits;
}

searchProducts('wireless headphones').catch(console.error);

Scenario - Create and inspect an A/B test

Create an A/B test between two index configurations and retrieve its status.

import { abtestingClient } from '@algolia/client-abtesting';
import type { AddABTestsRequest, ABTestResponse } from '@algolia/client-abtesting';

const client = abtestingClient(
  process.env.ALGOLIA_APP_ID!,
  process.env.ALGOLIA_API_KEY!,
  'us'
);

async function createTest(): Promise<ABTestResponse> {
  const request: AddABTestsRequest = {
    name: 'Ranking experiment v1',
    endAt: '2025-12-31T00:00:00.000Z',
    variants: [
      { index: 'products', trafficPercentage: 60 },
      { index: 'products_reranked', trafficPercentage: 40 },
    ],
  };

  const result = await client.addABTests(request);
  console.log('Created A/B test ID:', result.abTestID);

  const test = await client.getABTest({ id: result.abTestID });
  console.log('Status:', test.status);
  return result;
}

createTest().catch(console.error);

Scenario - List all running A/B tests

Fetch a paginated list of active experiments and filter by status.

import { abtestingClient } from '@algolia/client-abtesting';
import type { ListABTestsResponse, ABTest } from '@algolia/client-abtesting';

const client = abtestingClient(
  process.env.ALGOLIA_APP_ID!,
  process.env.ALGOLIA_API_KEY!,
  'us'
);

async function getRunningTests(): Promise<ABTest[]> {
  const response: ListABTestsResponse = await client.listABTests({
    offset: 0,
    limit: 20,
  });

  const running = (response.abtests ?? []).filter(
    (t) => t.status === 'running'
  );

  running.forEach((t) => {
    console.log(`[${t.abTestID}] ${t.name} — ends ${t.endAt}`);
  });

  return running;
}

getRunningTests().catch(console.error);

Scenario - Send insight events

Record click and conversion events for personalization and analytics.

import { insightsClient } from '@algolia/client-insights';

const client = insightsClient(
  process.env.ALGOLIA_APP_ID!,
  process.env.ALGOLIA_API_KEY!
);

async function trackClick(userToken: string, objectID: string) {
  await client.pushEvents({
    events: [
      {
        eventType: 'click',
        eventName: 'Product Clicked',
        index: 'products',
        userToken,
        objectIDs: [objectID],
        timestamp: Date.now(),
      },
    ],
  });
  console.log('Event sent');
}

trackClick('user-42', 'SKU-9001').catch(console.error);

File walkthrough

• abtesting/ - Self-contained A/B testing package; index.js resolves to the prebuilt Node CJS bundle; model/ contains generated TypeScript interfaces; src/abtestingV3Client.ts is the client implementation; builds/ has platform-specific entry points.
• advanced-personalization/ - Advanced personalization package with the same layout: index.js → CJS bundle, model/ → typed request/response interfaces, src/ → client logic.
• algoliasearch/ - Umbrella package; index.js → dist/node.cjs; re-exports search, recommend, and analytics under one import.
• client-abtesting/ - Source implementation consumed by the abtesting/ build wrapper.
• client-analytics/ - Analytics API client source.
• client-common/ - Auth, retry strategy, request serialization, shared types used by all other clients.
• client-insights/ - Insights event-push client source.
• client-personalization/ - Personalization strategy client source.
• client-query-suggestions/ - Query suggestions configuration client source.
• client-search/ - Full search client: index settings, object CRUD, batch operations.
• composition/ - Experimental composition client aggregating multiple API surfaces.
• ingestion/ - Connector and pipeline management for data ingestion into Algolia.
• logger-console/ - Pluggable logger that writes to console.log/console.error.
• monitoring/ - Cluster health and status monitoring client.
• recommend/ - Recommendations engine client: related products, trending, frequently bought together.
• requester-browser-xhr/ - XHR transport adapter for browser environments.
• requester-fetch/ - Fetch API transport for modern browsers and edge workers.
• requester-node-http/ - Native Node.js transport using http/https modules.
• requester-testing/ - Deterministic mock transport for unit and integration testing.

Common pitfalls and fixes

• Missing dist/ files when importing from the vendor copy: The index.js files resolve to dist/builds/node.cjs; run pnpm build inside each package or import directly from src/ TypeScript files instead.
• Region not specified for regional clients: abtestingClient and advancedPersonalizationClient require an explicit region string ('us' or 'de'); omitting it causes routing errors.
• ESM/CJS interop with bundlers: Use moduleResolution: "node16" or "bundler" in tsconfig.json; older "node" resolution may not find the exports map entries.
• Environment variables undefined at runtime: Ensure ALGOLIA_APP_ID and ALGOLIA_API_KEY are set before the process starts; the clients throw immediately if either is an empty string.
• TypeScript strict null errors on model fields: Many model fields are optional; always guard with ?? [] or optional chaining before iterating (e.g. response.abtests ?? []).
• Wrong transport in edge/serverless environments: requester-node-http uses Node.js http which is unavailable in Cloudflare Workers; use requester-fetch (or the builds/fetch.ts entry) in those environments.

Vibe-coding prompt template

I have the Algolia JavaScript API Client source in `source/` and a usage guide
in `USAGE.md`. The upstream package is `algoliasearch-client-javascript`.

Please integrate this client into my project by following these steps:

1. Read `USAGE.md` completely before writing any code.
2. Install the required npm dependencies listed in `## Required dependencies`.
3. Add the tsconfig `paths` entries from `## Project setup` if I am importing
   from the local `source/` copy.
4. Create a file `src/algolia.ts` that initialises the `algoliasearch` client
   using `ALGOLIA_APP_ID` and `ALGOLIA_API_KEY` environment variables and
   exports the client instance.
5. Add a search helper function typed with the real model types from
   `source/client-search/`.
6. If I need A/B testing, add a second file `src/abtesting.ts` that
   initialises `abtestingClient` and exports `createTest` and `listTests`
   functions using the types from `source/abtesting/model/`.
7. Write a brief Jest test using `source/requester-testing/` as the mock
   transport so no real HTTP calls are made.
8. Show all imports using real exported symbol names from `USAGE.md` only.
9. Do not invent any methods or types not documented in `USAGE.md`.

License and credit

The Algolia JavaScript API Client is released under the MIT License (see source/abtesting/LICENSE and source/advanced-personalization/LICENSE). Source: algoliasearch-client-javascript on GitHub. Upstream npm package: algoliasearch.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

전체 설치 가이드와 연동 프롬프트는 구매 후 열람할 수 있습니다.

Nx Smart Monorepo Build and CI Platform

Automation, Utilities & Developer Tools

무료