Claude Code से Algolia Search लागू करने की Practical Guide

Code लिखने से पहले search का उद्देश्य तय करें

Algolia एक search SaaS है जो data को search index में रखता है और millisecond-level response देता है। छोटी website के लिए database कीLIKEquery काफी हो सकती है, लेकिन typo tolerance, facets, ranking, synonyms, click analytics और multilingual search आते ही custom implementation भारी हो जाती है।

Claude Code की असली ताकत सिर्फ search box बनाना नहीं है। आप इसे schema, routes, UI components, permissions और content model पढ़ाकर record shape, index settings, indexing pipeline, secured API keys, InstantSearch UI, analytics events और relevance review loop एक साथ design करा सकते हैं। Search feature तेज होना चाहिए, लेकिन उससे भी ज्यादा जरूरी है कि private data गलती से index में न जाए।

यह guide Algolia JavaScript API Client v5 पर आधारित है। v5 में पुरानेinitIndexpattern की जगह client methods मेंindexNameपास किया जाता है, जैसेclient.saveObjectsऔरclient.searchSingleIndex। Implementation से पहले officialJavaScript API Client v5, API clients और Claude Codecommon workflows देखें।

तीन practical use cases

Use case साफ होगा तो index design भी साफ रहेगा।

Use case	Data	Important settings	Main risk
Documentation search	articles, headings, body, tags	searchableAttributes, synonyms, highlighting	drafts या internal notes index होना
Product या course catalog	name, category, price, stock, popularity	facets, customRanking, Insights	stale price या stock
Internal knowledge search	FAQ, tickets, design notes	secured API key, filters, permission fields	private records leak होना

ClaudeCodeLab में यही pattern public blog search, training material search और template discovery के लिए काम करता है। UI से पहले यह तय करें कि कौन क्या देख सकता है, कौन से attributes ranking पर असर डालते हैं, और कौन से search terms training, templates या consultation page तक जाने चाहिए।

Search record को छोटा और safe रखें

Database row को पूरा Algolia में copy न करें। सिर्फ public display fields और ranking/filtering के लिए जरूरी metadata index करें। Email, payment ID, internal memo, unpublished content और raw API response को index से बाहर रखें।

{
  "objectID": "article_hi_claude-code-algolia-search",
  "title": "Claude Code से Algolia Search लागू करने की Practical Guide",
  "summary": "Index design, UI, analytics और review loop की practical guide",
  "content": "Published content से निकाला गया searchable text ही रखें",
  "locale": "hi",
  "section": "blog",
  "category": "use-cases",
  "tags": ["Claude Code", "Algolia", "search"],
  "visibility": "public",
  "allowedTeams": [],
  "slug": "claude-code-algolia-search",
  "url": "/hi/blog/claude-code-algolia-search",
  "publishedAt": "2025-11-15",
  "updatedAt": "2026-06-01",
  "updatedAtTimestamp": 1780272000,
  "popularity": 42,
  "conversionScore": 7,
  "readingMinutes": 12,
  "thumbnail": "/images/hero/hero-090.png"
}

objectIDstable होना चाहिए। Title या URL बदलने पर ID बदल गई तो analytics history और relevance tuning टूट जाती है। Articles के लिएarticle_locale_slugऔर products के लिएproduct_databaseIduseful pattern है।

Algolia v5 indexing script

Dependencies install करें।

npm install algoliasearch@5 dotenv

.envमेंALGOLIA_APP_ID, ALGOLIA_ADMIN_KEYऔर optionalALGOLIA_INDEX_NAMEरखें। Admin key हमेशा server-side रहेगी।

// scripts/index-articles.ts
import "dotenv/config";
import { algoliasearch } from "algoliasearch";

type SearchRecord = {
  objectID: string;
  title: string;
  summary: string;
  content: string;
  locale: "hi" | "en";
  section: "blog" | "docs" | "product";
  category: string;
  tags: string[];
  visibility: "public" | "restricted";
  allowedTeams: string[];
  slug: string;
  url: string;
  publishedAt: string;
  updatedAt: string;
  updatedAtTimestamp: number;
  popularity: number;
  conversionScore: number;
  readingMinutes: number;
  thumbnail: string;
};

const appId = process.env.ALGOLIA_APP_ID;
const adminKey = process.env.ALGOLIA_ADMIN_KEY;
const indexName = process.env.ALGOLIA_INDEX_NAME ?? "claudecodelab_articles";

if (!appId || !adminKey) {
  throw new Error("ALGOLIA_APP_ID and ALGOLIA_ADMIN_KEY are required");
}

const client = algoliasearch(appId, adminKey);

const records: SearchRecord[] = [
  {
    objectID: "article_hi_claude-code-algolia-search",
    title: "Claude Code से Algolia Search लागू करने की Practical Guide",
    summary: "Index design, UI, analytics और review loop की practical guide",
    content: "Published content से निकाला गया searchable text ही index करें।",
    locale: "hi",
    section: "blog",
    category: "use-cases",
    tags: ["Claude Code", "Algolia", "search"],
    visibility: "public",
    allowedTeams: [],
    slug: "claude-code-algolia-search",
    url: "/hi/blog/claude-code-algolia-search",
    publishedAt: "2025-11-15",
    updatedAt: "2026-06-01",
    updatedAtTimestamp: 1780272000,
    popularity: 42,
    conversionScore: 7,
    readingMinutes: 12,
    thumbnail: "/images/hero/hero-090.png"
  }
];

await client.setSettings({
  indexName,
  indexSettings: {
    searchableAttributes: [
      "unordered(title)",
      "unordered(summary)",
      "content",
      "tags",
      "category"
    ],
    attributesForFaceting: [
      "filterOnly(visibility)",
      "filterOnly(locale)",
      "filterOnly(allowedTeams)",
      "searchable(category)",
      "searchable(tags)",
      "section"
    ],
    customRanking: [
      "desc(conversionScore)",
      "desc(popularity)",
      "desc(updatedAtTimestamp)"
    ],
    attributesToRetrieve: [
      "title",
      "summary",
      "locale",
      "section",
      "category",
      "tags",
      "url",
      "updatedAt",
      "thumbnail"
    ],
    attributesToHighlight: ["title", "summary", "content"],
    typoTolerance: true,
    removeWordsIfNoResults: "lastWords"
  }
});

await client.saveSynonyms({
  indexName,
  synonymHit: [
    {
      objectID: "claude-code-names",
      type: "synonym",
      synonyms: ["Claude Code", "claude code", "क्लॉड कोड"]
    },
    {
      objectID: "search-hi",
      type: "synonym",
      synonyms: ["search", "site search", "full-text search", "खोज"]
    }
  ],
  clearExistingSynonyms: true
});

const { taskID } = await client.saveObjects({
  indexName,
  objects: records
});

await client.waitForTask({ indexName, taskID });
console.log(`Indexed ${records.length} records into ${indexName}`);

searchableAttributesमें ऊपर वाले fields ज्यादा important माने जाते हैं। Permission fields कोfilterOnlyरखें ताकि वे results restrict करें, लेकिन user-facing facets न बनें।

Search endpoint और secured API key

Public search के लिए browser में search-only key रखी जा सकती है। Admin key या write-capable key कभी browser में न भेजें। User या team के हिसाब से results restrict करने हों तो server पर secured API key generate करें। Algolia कीAPI keys guideइस model को detail में बताती है।

// app/api/search-key/route.ts
import { algoliasearch } from "algoliasearch";
import { NextResponse } from "next/server";

const appId = process.env.ALGOLIA_APP_ID!;
const searchKey = process.env.ALGOLIA_SEARCH_KEY!;
const indexName = process.env.ALGOLIA_INDEX_NAME ?? "claudecodelab_articles";

export async function GET() {
  const user = { id: "user_123", teamIds: ["training"] };
  const client = algoliasearch(appId, searchKey);

  const securedApiKey = client.generateSecuredApiKey({
    parentApiKey: searchKey,
    restrictions: {
      restrictIndices: indexName,
      filters: `visibility:public OR allowedTeams:${user.teamIds[0]}`,
      userToken: user.id,
      validUntil: Math.floor(Date.now() / 1000) + 60 * 30
    }
  });

  return NextResponse.json({ appId, indexName, apiKey: securedApiKey });
}

Server-side search endpoint बनाना हो तो input limit करें और केवल safe attributes return करें। Search method के लिए officialSearch an indexदेखें।

// app/api/search/route.ts
import { algoliasearch } from "algoliasearch";
import { NextRequest, NextResponse } from "next/server";

const client = algoliasearch(
  process.env.ALGOLIA_APP_ID!,
  process.env.ALGOLIA_SEARCH_KEY!
);
const indexName = process.env.ALGOLIA_INDEX_NAME ?? "claudecodelab_articles";

export async function GET(request: NextRequest) {
  const query = request.nextUrl.searchParams.get("q")?.slice(0, 80) ?? "";
  const locale = request.nextUrl.searchParams.get("locale") ?? "hi";

  const result = await client.searchSingleIndex({
    indexName,
    searchParams: {
      query,
      filters: `visibility:public AND locale:${locale}`,
      hitsPerPage: 10,
      attributesToRetrieve: ["title", "summary", "url", "category", "tags"],
      clickAnalytics: true
    }
  });

  return NextResponse.json({
    hits: result.hits,
    queryID: result.queryID,
    nbHits: result.nbHits
  });
}

InstantSearch UI

InstantSearch.jssearch box, facets, highlighting, stats और pagination के widgets देता है।

// components/ArticleSearch.tsx
"use client";

import { liteClient as algoliasearch } from "algoliasearch/lite";
import {
  Configure,
  Highlight,
  Hits,
  InstantSearch,
  Pagination,
  RefinementList,
  SearchBox,
  Stats
} from "react-instantsearch";

type HitProps = {
  hit: {
    objectID: string;
    title: string;
    summary: string;
    url: string;
    category: string;
    tags: string[];
    updatedAt: string;
  };
};

const searchClient = algoliasearch(
  process.env.NEXT_PUBLIC_ALGOLIA_APP_ID!,
  process.env.NEXT_PUBLIC_ALGOLIA_SEARCH_KEY!
);

function HitCard({ hit }: HitProps) {
  return (
    <article className="rounded border p-4">
      <a href={hit.url} className="font-bold">
        <Highlight attribute="title" hit={hit} />
      </a>
      <p className="mt-2 text-sm text-gray-600">
        <Highlight attribute="summary" hit={hit} />
      </p>
      <p className="mt-2 text-xs text-gray-500">
        {hit.category} · {hit.updatedAt}
      </p>
    </article>
  );
}

export function ArticleSearch() {
  return (
    <InstantSearch searchClient={searchClient} indexName="claudecodelab_articles">
      <Configure
        hitsPerPage={8}
        filters="visibility:public AND locale:hi"
        clickAnalytics
      />
      <SearchBox placeholder="Claude Code articles search करें" />
      <Stats />
      <div className="mt-6 grid gap-6 md:grid-cols-[220px_1fr]">
        <aside>
          <h2 className="text-sm font-bold">Category</h2>
          <RefinementList attribute="category" searchable />
          <h2 className="mt-4 text-sm font-bold">Tags</h2>
          <RefinementList attribute="tags" searchable />
        </aside>
        <main>
          <Hits hitComponent={HitCard} />
          <Pagination className="mt-6" />
        </main>
      </div>
    </InstantSearch>
  );
}

Analytics और review loop

Search launch होने के बाद review शुरू होता है। Queries, zero-result searches, click position और conversion events देखकर records, settings, synonyms और UI बदलें।

// lib/search-insights.ts
import aa from "search-insights";

aa("init", {
  appId: process.env.NEXT_PUBLIC_ALGOLIA_APP_ID!,
  apiKey: process.env.NEXT_PUBLIC_ALGOLIA_SEARCH_KEY!,
  useCookie: true
});

export function trackSearchClick(params: {
  indexName: string;
  objectID: string;
  queryID: string;
  position: number;
}) {
  aa("clickedObjectIDsAfterSearch", {
    eventName: "Article Clicked",
    index: params.indexName,
    queryID: params.queryID,
    objectIDs: [params.objectID],
    positions: [params.position]
  });
}

Claude Code को reviewer की तरह use करें।

You are the search quality reviewer for ClaudeCodeLab.
Review Algolia queries, zero-result searches, top 10 results, CTR, and conversions.

Output:
| query | problem | cause | proposed change | risk | priority |

Rules:
- Do not add private fields to the index.
- Separate changes into settings, synonyms, record content, and UI.
- Check whether the expected article appears in the top 3.
- Decide whether a synonym, title rewrite, body edit, or facet change is best.
- Check whether training, templates, and consultation CTAs match search intent.

Common pitfalls

पहली गलती गलत key expose करना है।NEXT_PUBLIC_environment variables browser में जाते हैं। वहाँ सिर्फ search-only key या server-generated secured API key रखें।

दूसरी गलती बहुत ज्यादा fields index करना है। Private field Algolia में चला गया तो मानें कि वह retrieve हो सकता है। Records साफ करें औरattributesToRetrieveकम रखें।

तीसरी गलती ranking को intuition पर freeze करना है। Title और summary से शुरू करें, फिरconversionScore, popularityऔर freshness को tie-breaker बनाएं। Insights के आधार पर weekly review करें।

चौथी गलती synonyms को बहुत broad बनाना है। “AI”, “Claude” और “ChatGPT”को बिना evidence जोड़ने से intent धुंधला हो जाता है। Synonyms तभी जोड़ें जब logs zero-result या spelling variation दिखाएं।

पाँचवीं गलती task complete होने से पहले test करना है। Settings, synonyms और records save करने के बादwaitForTaskका इंतजार करें।

Monetization path से जोड़ना

Search revenue path का हिस्सा है। “Algolia search” query इस guide पर आए, “CLAUDE.md template” queryCLAUDE.md templatesपर जाए, और team rollout वाली queryClaudeCodeLab consultationतक पहुँचे। Related internal links के लिएSearch Functionality GuideऔरPerformance Optimizationभी जोड़ें।

ClaudeCodeLab Claude Code training, prompt templates, CLAUDE.md templates और implementation consultation में मदद कर सकता है। Algolia search जोड़ने से पहले public fields, ranking metrics और high-intent queries की list बना लें।

Summary

Claude Code और Algolia साथ में तब सबसे अच्छे काम करते हैं जब search को product loop माना जाए: safe records, अलग keys, clear ranking, synced indexing, useful UI, analytics और regular review।

इस article में बताए गए flow को आजमाने पर सबसे बड़ा फायदा शुरुआत में ही record fields औरattributesToRetrieveकम करने से मिला। Claude Code वाला review prompt zero-result fixes, synonyms, content rewrites और training, templates, consultation CTAs को एक ही weekly process में review करने में मदद करता है।