algolia-ci-integration View full skill →

Build and review a bounded CI gate for Algolia index configuration and disposable-index smoke tests.

ReadGlobGrepWebFetchWriteEdit

Algolia CI Integration

Overview

This skill adds a deterministic CI lane for code that owns Algolia records, settings, or query behavior. It separates offline contract tests from an optional network smoke test against an explicitly disposable index.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Pin the Node dependency and runner version already supported by the repository.
Keep production application IDs, index names, and write credentials out of pull-request workflows.
Name disposable indices with a run-specific suffix and record their cleanup result.
Test the exact client methods used by the application; for JavaScript v5, index operations live on the client.

Authentication

Use a repository secret containing a custom key limited to the disposable index and required ACLs. Do not use an Admin key or expose any write key to forked pull requests.

Instructions

Map the package manager, test runner, Algolia wrapper, and current CI event permissions.
Add offline tests for record shaping, settings serialization, and query contracts.
Make the live smoke job opt-in or protected, with a unique non-production index name.
Create records, wait for the task, perform one known query, and collect request IDs on failure.
Delete the disposable index in a guaranteed cleanup step and report cleanup failure separately.
Verify untrusted forks cannot read secrets or execute the credentialed job.

Approval Boundaries

Do not enable secrets for untrusted fork code, reuse a production index, or delete an index whose generated name was not validated. Require review for workflow-permission changes.

Output

Return the workflow diff, secret and ACL requirements, offline results, smoke-test evidence, cleanup receipt, and the exact conditions under which the network job runs.

Error Handling

…

Condition	Response
Secret unavailable	Skip the protected smoke job while keeping offline tests required.
Index name is not disposable	Fail before the first write.

algolia-common-errors View full skill →

Diagnose Algolia request, credential, index, task, and query failures from concrete evidence.

ReadGlobGrepWebFetchWriteEdit

Algolia Error Triage

Overview

This skill turns an Algolia symptom into a reproducible diagnosis. It favors the response status, message, request ID, client version, operation, and target index over generic error folklore.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

A 403 is an authorization fact, not proof that an unrestricted key is required.
A successful write is asynchronous; compare the returned task ID and wait behavior before calling data stale.
A 404 can identify a missing index, application, route, or regional endpoint; preserve the full response.
A 429 must be interpreted from the returned message and current plan or key restrictions, not from a guessed universal quota.

Authentication

Inspect only redacted key metadata and ACL intent. Never print, paste, or replace a credential with an Admin key merely to make a failing request succeed.

Instructions

Capture the smallest failing call, status, message, request ID, application ID suffix, index name, and package version.
Classify the operation as search, indexing, settings, key management, analytics, or events.
Compare the operation with the intended key ACLs and index restrictions.
Reproduce against a safe test index or read-only query with the same client boundary.
Check task completion, index spelling, filters, attributes, and environment routing in that order.
Apply one correction, rerun the minimal reproduction, and record before-and-after evidence.

Approval Boundaries

Do not broaden ACLs, rotate keys, change production settings, or replay writes until the target and failure class are confirmed.

Output

Return the symptom, evidence, root-cause hypothesis, ruled-out alternatives, minimum fix, verification result, and any remaining uncertainty.

Error Handling

Condition	Response
401 or 403	Verify application/key pairing and required ACL; do not escalate privilege blindly.
404	Confirm endpoint, application, and exact index name.
429	Ho…

algolia-core-workflow-a View full skill →

Implement or review a single-index Algolia search contract with filters, facets, pagination, and highlighting.

ReadGlobGrepWebFetchWriteEdit

Algolia Search Contract

Overview

This skill defines the read path between application input and Algolia search results. It keeps query construction, allowed filters, pagination, and result projection explicit so UI behavior can be tested independently.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Use searchSingleIndex for one index and pass indexName plus searchParams on the v5 client.
Treat filters and facet filters as structured application inputs; do not concatenate untrusted syntax.
Request only attributes the interface needs and preserve objectID as the stable result identity.
Enable click analytics only when the product also implements the query ID and event contract.

Authentication

Browser search should use the search-only key or a backend-generated secured key. Write-capable credentials remain server-side.

Instructions

Inspect the installed client version, index settings, record schema, and current UI query state.
Define a typed search input with bounded query length, page, hits per page, filters, and facets.
Translate application filters through an allowlist rather than accepting raw filter strings.
Call the v5 search boundary and map hits into the application result type.
Test empty query, no results, special characters, pagination edges, and unavailable facets.
Verify returned attributes do not disclose fields the interface should not expose.

Approval Boundaries

Do not change index settings, enable analytics, or expose additional attributes as part of a read-path implementation without explicit review.

Output

Return the typed input/output contract, query builder, relevant tests, credential boundary, observed response metadata, and any required index-setting change.

Error Handling

…

Condition	Response
Invalid filter syntax	Reject or normalize at the application boundary.
Facet missing	Confirm the attribute is configured before changing the UI.

algolia-core-workflow-b View full skill →

Build a reliable Algolia indexing pipeline for full replacements, incremental updates, settings, synonyms, and rules.

ReadGlobGrepWebFetchWriteEdit

Algolia Indexing Contract

Overview

This skill designs the write path from an authoritative dataset to Algolia. It separates record transformation, validation, transport, task completion, and publication so a failed run cannot silently leave ambiguous search state.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Generate stable objectID values from source identities and reject duplicates before upload.
Choose saveObjects for bounded upserts and replaceAllObjects only for an intentional full-state replacement.
Wait for returned task IDs before verification or traffic cutover.
Version settings, synonyms, and rules as reviewable inputs; do not infer them from production state during deployment.

Authentication

Run indexing only from a trusted backend with a custom key restricted to the target indices and required write ACLs. Keep search-only keys out of indexing jobs.

Instructions

Identify the source of truth, deletion semantics, index aliases or replicas, and acceptable publication window.
Transform and validate records locally, including size, required fields, stable IDs, and prohibited data.
Select incremental or full replacement based on source deletion guarantees and rollback needs.
Submit bounded batches, retain task IDs, and wait for completion with an overall timeout.
Verify counts, sentinel records, settings hashes, and representative queries.
Record the source snapshot, target index, completed tasks, and rollback or prior-index path.

Approval Boundaries

Do not run a full replacement, delete records, change settings, or swap a production target until the source snapshot and rollback plan are approved.

Output

Return the data contract, operation choice, validation report, task receipts, post-write checks, deletion behavior, and rollback instructions.

Error Handling

Condition	Response
Duplicate objectID	Fail before upload and report source records.
Partial batch failure	Stop publicat…

algolia-cost-tuning View full skill →

Audit Algolia usage drivers and propose measurable cost controls without hard-coded plan prices.

ReadGlobGrepWebFetchWriteEdit

Algolia Usage and Cost Review

Overview

This skill correlates current Algolia billing and usage evidence with application behavior. It deliberately avoids embedding plan names, prices, free allowances, or assumptions that indexing is unmetered because commercial terms can change.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Treat the account's current invoice, usage dashboard, and contract as the authority for billable units.
Separate search traffic, records, replicas, indexing activity, analytics or AI features, and non-production duplication.
Measure request amplification caused by keystrokes, federated queries, retries, bots, and duplicate clients.
Recommend controls only when they preserve relevance, freshness, security, and product requirements.

Authentication

Use read-only account access or exported billing evidence. Do not put billing, usage, Analytics, or Admin credentials in frontend code or reports.

Instructions

Define the billing window, applications, indices, environments, replicas, and contract source in scope.
Capture current usage and invoice line items without copying secret values.
Trace major units back to callers, UI interactions, scheduled jobs, duplicated records, and optional features.
Quantify each candidate change with a baseline, expected delta, uncertainty, and product tradeoff.
Test request debouncing, caching, record trimming, environment retention, or replica changes in a safe environment.
Reconcile the next usage window and retain a rollback trigger for relevance or freshness regressions.

Approval Boundaries

Do not delete indices, remove replicas, change plans, disable analytics, or cache personalized results without owner approval and measured impact.

Output

Return the evidence window, current drivers, ranked opportunities, estimated ranges rather than false precision, validation plan, approvals, and post-change reconciliation.

Error Handling

Condition	Response
Invoice and dashboard disagree	Record the reporting wi…

algolia-data-handling View full skill →

Design and audit the data lifecycle for records and user events sent to Algolia.

ReadGlobGrepWebFetchWriteEdit

Algolia Data Handling Review

Overview

This skill maps which data leaves the source system, how it becomes searchable records or events, and how correction and deletion propagate. It does not claim legal compliance; it produces technical evidence for the responsible privacy owner.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Index only fields required for retrieval, ranking, filtering, display, or approved analytics.
Treat attributesToRetrieve as response shaping, not as a substitute for excluding sensitive data from records.
Keep source-system identity mappings so corrections and deletions are reproducible.
Handle record deletion and Insights user-token deletion as separate surfaces with separate evidence.

Authentication

Use a restricted backend write key for record changes and the documented authorization for user-data deletion. Never include raw secrets or direct personal identifiers in logs or example events.

Instructions

Inventory record fields, derived attributes, event fields, user tokens, environments, and downstream exports.
Classify each field by purpose, sensitivity, source authority, and deletion requirement.
Remove unnecessary fields before indexing and test that UI and ranking behavior still work.
Implement idempotent correction and deletion paths with request IDs and target indices.
Verify absence using bounded lookups and preserve evidence without retaining the deleted value.
Document retention ownership, incident escalation, and gaps for privacy or legal review.

Approval Boundaries

Do not make legal conclusions, bulk-delete records, change retention policy, or expose protected values while verifying a request.

Output

Return the data-flow map, field inventory, minimization changes, deletion/correction procedure, verification evidence, unresolved provider retention questions, and named policy owner.

Error Handling

…

Condition	Response
Identity mapping missing	Stop and reconcile the source identity before deletion.

algolia-debug-bundle View full skill →

Collect a bounded, secret-safe Algolia diagnostic bundle for an incident or support escalation.

ReadGlobGrepWebFetchWriteEdit

Algolia Redacted Debug Bundle

Overview

This skill assembles code, configuration shape, client versions, redacted request evidence, task IDs, and reproduction steps without copying API keys, full records, or unrestricted account data.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Prefer local configuration names and hashes over live secret or key inspection.
Collect the smallest failing request and response; redact credentials, personal data, and unrelated record fields.
Include timestamps, regions or hosts, request IDs, task IDs, and client versions when available.
Create a manifest before sharing so reviewers can see every included file and redaction rule.

Authentication

Do not fetch, print, validate, or transmit secret values. If a support workflow needs account evidence, use a separately approved read-only credential and preserve only redacted results.

Instructions

Define the incident, recipient, allowed data classes, time window, and maximum bundle size.
Inspect local dependencies, wrapper code, environment variable names, index configuration, and recent relevant logs.
Reproduce one safe read or disposable-index operation and capture redacted request metadata.
Scan every artifact for keys, tokens, emails, user tokens, record payloads, and unrelated secrets.
Build a plain-text manifest with collection source, hash, redaction action, and omission reason.
Review the manifest and bundle contents before any external transfer.

Approval Boundaries

Do not use an Admin key for diagnosis, archive an entire environment, collect production records wholesale, or send the bundle automatically.

Output

Return the reproduction, dependency versions, redacted evidence, artifact manifest, secret-scan result, omitted evidence, and a human-approved handoff path.

Error Handling

…

Condition	Response
Potential secret found	Remove the artifact or redact it, then rescan.
Reproduction mutates production	Stop and move to a disposable target.

algolia-deploy-integration View full skill →

Plan and verify deployment of an Algolia-backed application with separated browser and server credentials.

ReadGlobGrepWebFetchWriteEdit

Algolia Deployment Integration

Overview

This skill coordinates application deployment with the Algolia assets it depends on. It treats code, records, settings, keys, and events as separate release surfaces with explicit ordering and rollback.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

The browser receives only a search-only or secured key; write-capable keys stay in trusted server or job environments.
Pin application and index names per environment rather than deriving production targets from branch names.
Complete indexing tasks and representative queries before routing production traffic.
Deploy event instrumentation only after user-token, consent, query ID, and validation behavior are reviewed.

Authentication

Provision custom least-privilege keys through the approved secret store. Never place Admin keys in static build variables, client bundles, deployment logs, or preview environments.

Instructions

Map the deploy platform, runtime boundaries, environment variables, index targets, and current rollback mechanism.
Verify client packages and API usage against the pinned lockfile and current first-party docs.
Prepare or verify target records, settings, synonyms, and rules before the application cutover.
Deploy server and browser configuration with credential separation and redacted logging.
Run a read-only health check plus representative search tests against the intended target.
Record release SHA, index state, task receipts, smoke results, and rollback trigger.

Approval Boundaries

Do not overwrite production indices, rotate keys, promote settings, or enable events as an implicit side effect of application deployment.

Output

Return the release topology, environment map, credential classification, ordered deployment plan, smoke evidence, rollback steps, and unresolved approvals.

Error Handling

Condition	Response
Browser bundle contains write key	Stop deployment and rotate the exposed credential.
Target index is stale	H…

algolia-enterprise-rbac View full skill →

Map workforce roles and application actors to Algolia team permissions, API-key ACLs, and secured-key restrictions.

ReadGlobGrepWebFetchWriteEdit

Algolia Enterprise Access Design

Overview

This skill separates human dashboard access, backend service access, browser search access, and tenant-scoped access. It verifies current account capabilities instead of assuming every plan exposes the same roles or SSO features.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Treat current dashboard settings and contracted features as the authority for workforce roles and SSO availability.
Map service operations to documented API-key ACLs and index restrictions.
Generate secured search keys only on a trusted backend and require at least one restriction.
Model application tenancy in filters and key restrictions; do not confuse that model with provider workforce RBAC.

Authentication

Review key descriptions, ACLs, restrictions, owners, and rotation dates without exporting secret values. Production services should use organization-owned, least-privilege keys.

Instructions

Inventory human roles, service identities, browser clients, environments, indices, and tenant boundaries.
Capture current provider roles and SSO features from the account or contract, marking unavailable evidence.
Map each actor to operations, ACLs, index restrictions, validity, and credential owner.
Test denied and allowed operations using safe targets and redacted evidence.
Document joiner, mover, leaver, key rotation, break-glass, and audit-review procedures.
Identify excessive grants, orphaned credentials, or tenant escape paths and propose bounded remediation.

Approval Boundaries

Do not enable SSO, change team roles, revoke keys, or alter tenant filters without owner approval and a tested recovery path.

Output

Return the actor matrix, role and ACL mapping, current-plan evidence, denied-path tests, lifecycle controls, findings, and remediation approvals.

Error Handling

Condition	Response
Feature absent from current account	Record it as unavailable; do not infer entitlement.
Actor requires broad ACL	Split duties o…

algolia-hello-world View full skill →

Create a minimal Algolia JavaScript v5 indexing and search proof using a disposable index.

ReadGlobGrepWebFetchWriteEdit

Algolia Verified First Search

Overview

This skill proves the smallest complete write-read-cleanup cycle: create known records, wait for the indexing task, query one record, and remove the disposable index after review.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Use the installed algoliasearch v5 client; methods such as saveObjects, waitForTask, and searchSingleIndex are called on the client.
Assign explicit objectID values so verification is deterministic.
Use a new disposable index, never an existing production index.
Treat cleanup as an observed task with its own result.

Authentication

Use a custom backend key restricted to the disposable index and necessary operations. The browser should never receive this write credential.

Instructions

Confirm the package version, application ID, credential source, and validated disposable index name.
Create two non-sensitive records with stable object IDs.
Save the records and retain the returned task ID.
Wait for that task, then search for one unique value with searchSingleIndex.
Assert the expected object ID and record the request metadata without secrets.
After human confirmation, delete the disposable index and verify cleanup.

Approval Boundaries

Do not use a production index, copy an Admin key into source, or delete an index until its exact disposable name is displayed and approved.

Output

Return package and API evidence, the redacted configuration, write and wait task IDs, search assertion, cleanup result, and next recommended integration step.

Error Handling

Condition	Response
Authentication fails	Verify application/key pairing and required ACL.
Search is empty after write	Wait for the recorded task and confirm index name.
Unexpected existing records	Stop; the index is not disposable.
Cleanup not approved	Leave the index and report its exa…

algolia-incident-runbook View full skill →

Diagnose and manage an Algolia-backed search incident with evidence, containment, and reversible recovery.

ReadGlobGrepWebFetchWriteEdit

Algolia Search Incident Runbook

Overview

This skill runs a product-owned incident process without assuming the provider is or is not at fault. Severity and response targets come from the organization's runbook, while diagnosis uses application, provider, and data-pipeline evidence.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Separate availability, authorization, freshness, latency, relevance, and event-collection symptoms.
Check provider status as one signal, not as the root-cause conclusion.
Preserve request IDs, task IDs, deployment SHAs, settings changes, and source snapshots.
Prefer traffic rollback, prior index targets, or feature degradation paths that are already tested.

Authentication

Use read-only or narrowly scoped incident credentials. Never paste keys into tickets, chat, commands, screenshots, or diagnostic bundles.

Instructions

Declare incident owner, affected journey, start time, severity source, and current user impact.
Freeze unrelated changes and capture recent releases, indexing runs, key changes, and provider status.
Run a known read-only query and compare application, direct client, and source-of-truth results.
Classify the failure surface and choose the smallest reversible containment.
Verify recovery with synthetic and representative user queries, not only HTTP success.
Record timeline, evidence, decisions, cleanup, follow-up owners, and rollback readiness.

Approval Boundaries

Do not invent severity targets, rotate credentials, rebuild production, change relevance settings, or delete an index without the incident commander's approval.

Output

Return the incident classification, timeline, evidence links, containment action, recovery checks, customer impact, unresolved risks, and follow-up tasks.

Error Handling

Condition	Response
Provider status unclear	Continue application and data-path diagnosis while monitoring official status.
Credential suspected exposed	Escalate rotation through the app…

algolia-install-auth View full skill →

Install and verify the Algolia JavaScript v5 client with least-privilege credential separation.

ReadGlobGrepWebFetchWriteEdit

Algolia Install and Authentication

Overview

This skill establishes the package and credential boundary before feature work. It distinguishes the application ID from API keys and separates browser search from trusted write operations.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Inspect and follow the repository's package manager and lockfile rather than installing an unpinned latest package.
Use algoliasearch v5 imports and client-level methods; do not introduce the removed initIndex pattern.
Expose only a search-only or appropriately secured key in browser configuration.
Use custom keys with minimum ACLs and index restrictions for backend jobs.

Authentication

Load credentials through the repository's approved secret mechanism. Never print values, commit .env files, or use the Admin key as the default backend credential.

Instructions

Inspect runtime, package manager, lockfile, existing wrappers, and environment conventions.
Select a compatible pinned v5 version and add it through the native package workflow.
Define separate environment names for application ID, browser search key, and server write key.
Create one client factory per trust boundary and reject missing configuration without echoing values.
Verify browser search with a read-only query and backend writes only against a disposable index.
Scan built assets and source history for accidental write-key exposure.

Approval Boundaries

Do not install dependencies, create provider keys, alter secret stores, or rotate existing credentials outside the repository and account scope provided.

Output

Return the dependency diff, client factories, environment-name contract, key/ACL matrix, verification results, secret-scan evidence, and remaining setup actions.

Error Handling

Condition	Response
v4 API appears in code	Use the official v5 migration guide before mixing patterns.
Key rejected	Verify application pairing, ACL, restricti…

algolia-local-dev-loop View full skill →

Create a fast local development loop for Algolia record transforms and search behavior without contaminating shared indices.

ReadGlobGrepWebFetchWriteEdit

Algolia Local Development Loop

Overview

This skill combines deterministic offline tests with an optional disposable-index integration test. It makes the local loop useful without pretending a mock reproduces provider ranking, task timing, or authorization.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Keep record transformation and query construction in pure functions that can be tested offline.
Mock only the application-owned client boundary, not internal SDK implementation details.
Use unique disposable index names for live checks and never reuse production credentials.
Wait for write tasks and clean up live fixtures explicitly.

Authentication

Offline tests need no credential. Optional live tests use a custom key restricted to the disposable prefix and are disabled when credentials are absent.

Instructions

Inspect the current client wrapper, package scripts, fixtures, and test framework.
Extract pure record-shaping and query-building functions with focused unit tests.
Create a typed adapter and mock its application-level responses and failures.
Add an opt-in live test that validates a generated disposable index name.
Write known records, wait, query, assert, and clean up while retaining task receipts.
Document how developers select offline versus live mode and how stale test indices are reported.

Approval Boundaries

Do not require live credentials for the default test command, share a personal Admin key, or clean up any index outside the validated disposable prefix.

Output

Return the local scripts, test boundary, fixtures, live-test guard, cleanup behavior, and evidence for both credential-free and optional integration modes.

Error Handling

…

Condition	Response
Credential absent	Run offline tests and report the live test as skipped.
Mock diverges from adapter	Update the adapter contract and its typed fixture together.
Disposable prefix invalid	Fail before any network write.

algolia-migration-deep-dive View full skill →

Plan and execute a reversible migration from another search system or legacy index design to Algolia.

ReadGlobGrepWebFetchWriteEdit

Algolia Search Migration

Overview

This skill treats migration as a measured compatibility program: source data, query semantics, ranking, filters, UI behavior, traffic, and rollback are assessed separately before cutover.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Preserve the source system as the rollback authority until acceptance criteria pass.
Translate capabilities from observed queries and product journeys, not feature-name similarity.
Build a new target index and avoid in-place destructive conversion.
Compare relevance with a representative, owner-approved query set and explicit tolerances.

Authentication

Use separate least-privilege credentials for source reads, Algolia writes, and browser search. Keep all secret material outside migration artifacts.

Instructions

Inventory source schema, analyzers, queries, filters, facets, ranking behavior, traffic, and operational constraints.
Define the Algolia record model, stable IDs, settings, synonyms, rules, and unsupported semantic gaps.
Backfill a new target index from a reproducible source snapshot and retain task receipts.
Run structural checks, representative query comparisons, latency observations, and UI acceptance tests.
Shadow or canary traffic when available, with named rollback thresholds and owners.
Cut over only after approval, then reconcile drift and retain the rollback window.

Approval Boundaries

Do not overwrite the current production index, declare relevance equivalence from a few queries, or retire the source system before rollback expiry.

Output

Return the capability map, data transform, gap register, backfill evidence, query comparison, cutover plan, acceptance decision, and rollback procedure.

Error Handling

Condition	Response
Unsupported query feature	Document the gap and design an approved product alternative.
Record counts differ	Reconcile filtering, deletes, and source snapshot boundaries.
Relevance regresses	Keep …

algolia-multi-env-setup View full skill →

Design isolated Algolia development, staging, preview, and production targets with explicit promotion rules.

ReadGlobGrepWebFetchWriteEdit

Algolia Multi-Environment Setup

Overview

This skill makes environment isolation an application-owned contract. It does not assume one provider topology: separate applications, index namespaces, or a combination may be selected from security, data, cost, and operational requirements.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Map every runtime environment to an explicit application ID, index namespace, credential owner, and data classification.
Prevent preview or branch input from selecting an arbitrary production index.
Promote versioned settings and transforms through review rather than copying unknown live state.
Define lifecycle and cleanup for ephemeral indices before creating them.

Authentication

Use separate custom keys and secret scopes for each environment. Browser builds receive only the search credential for their resolved environment.

Instructions

Inventory applications, indices, replicas, keys, deployment environments, data sources, and retention rules.
Choose isolation boundaries based on blast radius, data policy, feature parity, and verified current commercial terms.
Implement an allowlisted environment resolver with no production fallback for unknown values.
Define reproducible record, settings, synonym, and rule promotion artifacts.
Test cross-environment denial, preview naming, cleanup, and production-selection safeguards.
Document owners, rotation, promotion, rollback, retention, and orphan-index review.

Approval Boundaries

Do not create applications, copy production data, share keys, or delete preview indices until topology and data-policy owners approve.

Output

Return the environment matrix, selected topology and tradeoffs, configuration resolver, key scopes, promotion flow, isolation tests, and lifecycle controls.

Error Handling

Condition	Response
Unknown environment	Fail closed instead of selecting production.
Preview requests production data	Reject unless an explicit approved sanitized source e…

algolia-observability View full skill →

Instrument an Algolia integration for actionable availability, latency, freshness, relevance, and event-health signals.

ReadGlobGrepWebFetchWriteEdit

Algolia Search Observability

Overview

This skill instruments the application-owned search journey rather than substituting generic provider claims. It connects client outcomes, request IDs, index publication, source freshness, and product-level relevance indicators.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Derive thresholds and objectives from the product SLO and measured baseline; do not use universal latency numbers.
Separate application latency from Algolia request latency and rendering time.
Track source snapshot to completed indexing task to searchable sentinel for freshness.
Treat event delivery and query-ID coverage as their own health surface.

Authentication

Telemetry must exclude API keys, raw personal data, sensitive queries, and unrestricted record payloads. Use approved read-only monitoring access where provider data is needed.

Instructions

Define the user journey, owned SLOs, current baseline, and incident-routing owner.
Instrument operation, outcome, duration, index alias, environment, SDK version, request ID, and bounded retry count.
Add freshness markers linking source snapshot, task completion, and searchable sentinel.
Measure no-result and event coverage using privacy-reviewed aggregation.
Build dashboards and alerts from sustained error-budget or baseline deviation, not a copied threshold.
Test telemetry during success, denial, timeout, stale-index, and event-failure scenarios.

Approval Boundaries

Do not log secrets or raw sensitive queries, create arbitrary alert thresholds, or enable high-cardinality labels without review.

Output

Return the signal catalog, field and redaction schema, SLO mapping, dashboards, alerts, synthetic checks, test evidence, and known blind spots.

Error Handling

Condition	Response
Request ID unavailable	Preserve local trace correlation and full redacted error metadata.
High cardinality detected	Aggregate or hash approved identifiers.
Provider and app l…

algolia-performance-tuning View full skill →

Analyze and optimize an Algolia search path using repository and production evidence instead of universal latency targets.

ReadGlobGrepWebFetchWriteEdit

Algolia Evidence-Based Performance Tuning

Overview

This skill decomposes perceived search time into input handling, network, provider request, response transfer, transformation, and render work. Optimization starts with an owned baseline and ends with a comparable measurement.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Set targets from the application's SLO, user geography, device mix, and measured baseline.
Inspect record and response shape before changing relevance or faceting settings.
Separate query count amplification from individual request latency.
Preserve correctness and relevance assertions alongside performance measurements.

Authentication

Run measurements with search-only or secured keys and sanitized representative queries. Do not expose write credentials or sensitive query logs.

Instructions

Define the journey, environment, representative query set, device/network profile, and success criteria.
Capture request count, component timings, payload size, cache behavior, result correctness, and render cost.
Locate the dominant segment before proposing changes.
Test bounded changes such as debouncing, stalled-search handling, requested attributes, query batching, or render work.
Compare before and after with the same harness and inspect relevance and freshness regressions.
Document the accepted change, uncertainty, monitoring signal, and rollback trigger.

Approval Boundaries

Do not change ranking, remove required facets, cache personalized responses, or publish claimed improvements without comparable evidence.

Output

Return the benchmark protocol, baseline distribution, bottleneck attribution, tested changes, before/after evidence, relevance checks, and rollout guardrails.

Error Handling

Condition	Response
Results are noisy	Increase samples and control geography, device, cache, and query set.
Faster response changes hits	Reject or obtain product acceptance for the relevance tradeoff.
Cli…

algolia-prod-checklist View full skill →

Run a fail-closed production readiness review for an Algolia-backed search release.

ReadGlobGrepWebFetchWriteEdit

Algolia Production Readiness Review

Overview

This skill consolidates the release evidence needed to decide whether an Algolia search surface is ready. It uses organization-owned SLOs and policies rather than hard-coded latency or response targets.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Bind all evidence to a release SHA, target application, index state, and source snapshot.
Verify least-privilege browser, server, indexing, monitoring, and event credentials separately.
Exercise representative relevance, filter, facet, empty-state, error, and accessibility paths.
Require tested rollback for both application code and index or settings state.

Authentication

Confirm secret-store ownership, key ACLs, index restrictions, rotation, and exposure scans. Never include credential values in the readiness packet.

Instructions

Freeze the candidate SHA and inventory code, records, settings, synonyms, rules, keys, and event surfaces.
Run schema, unit, integration, security, accessibility, and representative query gates.
Verify indexing tasks, counts, sentinel records, environment mapping, and rollback target.
Review observability against owned SLOs and exercise alert or incident routing.
Validate event consent, stable user tokens, query IDs, and provider event validation where applicable.
Record pass, fail, waiver owner, evidence link, expiration, and final go/no-go decision.

Approval Boundaries

Do not waive a failed security, rollback, data-integrity, or required branch-protection gate without the named authority and durable evidence.

Output

Return a release-bound checklist, evidence links, failed and waived gates, credential matrix, rollback rehearsal, approvers, and explicit go/no-go outcome.

Error Handling

…

Condition	Response
Evidence belongs to another SHA	Rerun or reject it.
Rollback not rehearsed	Hold production promotion.
Threshold has no owner	Treat it as observation, not a gate.

algolia-rate-limits View full skill →

Monitor and optimize Algolia request pressure using observed responses and bounded client behavior.

ReadGlobGrepWebFetchWriteEdit

Algolia Rate-Pressure Handling

Overview

This skill avoids invented universal quotas. It distinguishes key restrictions, current contractual usage, indexing pressure, transient transport failures, and application amplification using actual response evidence.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Interpret a 429 from its status, message, operation, request ID, and current account terms.
Inspect installed client behavior before layering application retries on top of SDK host retry.
Bound attempts, elapsed time, concurrency, and queue depth; retry only operations whose semantics are safe.
Protect interactive search from batch indexing through workload scheduling and backpressure.

Authentication

Use operation-specific, least-privilege keys. Never raise limits by replacing a restricted key with an Admin key or by removing tenant safeguards.

Instructions

Capture the failing operation, response, request ID, client version, concurrency, queue depth, and traffic source.
Check key restrictions and current usage or contract evidence without assuming a fixed quota.
Identify amplification from duplicate clients, unbounded concurrency, retries, bots, or oversized batches.
Define a retry budget with eligible errors, maximum attempts, elapsed timeout, jitter, and cancellation.
Apply concurrency limits or scheduling at the producer and test partial failure and shutdown.
Verify search health, queue recovery, idempotency, and alerting under controlled pressure.

Approval Boundaries

Do not load-test production, remove rate restrictions, increase plan limits, or retry non-idempotent work without owner approval.

Output

Return the observed limit evidence, pressure source, retry and queue policy, test results, residual capacity risk, and any commercial decision requiring an account owner.

Error Handling

Condition	Response
429 message ambiguous	Retain request ID and consult current provider support or docs.
Retry storm begins	Open the circ…

algolia-reference-architecture View full skill →

Design or review an Algolia search architecture across source data, indexing, query, UI, events, and operations.

ReadGlobGrepWebFetchWriteEdit

Algolia Reference Architecture

Overview

This skill produces an evidence-backed architecture tailored to the repository. It avoids presenting optional Algolia products or provider features as mandatory and makes trust, data, and failure boundaries explicit.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

The source system remains authoritative; Algolia is a derived search projection.
Separate indexing, browser search, server search, events, analytics, and workforce administration trust zones.
Version record transforms and search configuration with the application.
Design task completion, reconciliation, observability, and rollback before production cutover.

Authentication

Assign distinct least-privilege credentials to each machine actor and use provider team controls for human access. Generate tenant-scoped secured keys only on trusted servers.

Instructions

Map current components, data stores, producers, consumers, credentials, indices, and deployment environments.
Define the record contract, stable identity, deletion semantics, settings ownership, and freshness objective.
Choose query and UI boundaries, including browser versus server execution and tenant restrictions.
Add event flow only where consent, user-token, query-ID, and validation requirements are owned.
Model failures for source lag, partial indexing, key denial, provider degradation, and relevance regressions.
Produce architecture decisions, interfaces, tests, observability, rollout, and rollback.

Approval Boundaries

Do not select paid features, centralize unrestricted credentials, or authorize a migration solely from a generic reference diagram.

Output

Return the as-is and proposed boundaries, data and trust flows, decision records, interfaces, failure modes, security controls, validation plan, and phased rollout.

Error Handling

…

Condition	Response
Repository contradicts assumed topology	Follow repository evidence and revise the design.
Feature entitlement unknown

algolia-sdk-patterns View full skill →

Create or review a typed application adapter around the Algolia JavaScript v5 client.

ReadGlobGrepWebFetchWriteEdit

Algolia JavaScript v5 SDK Boundary

Overview

This skill centralizes the application contract around the installed v5 client without hiding important provider results. It keeps search, writes, task waits, and error metadata testable and explicit.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Create clients at trust boundaries and inject them into adapters rather than constructing them in every call site.
For v5, call operations on the client and pass indexName; do not restore initIndex.
Return typed application results while preserving request IDs, task IDs, and provider error context.
Put retry, timeout, batching, and index resolution policies in one reviewed layer.

Authentication

Accept credentials from the approved runtime configuration and never expose them through adapter return values, exceptions, logs, or browser/server boundary mistakes.

Instructions

Inventory every SDK import, installed version, client construction, index name, and direct call.
Group use cases into search, indexing, configuration, events, analytics, or administration boundaries.
Define typed inputs and outputs plus explicit timeout, task-wait, and error behavior.
Implement the smallest adapter and migrate one caller with contract tests.
Test success, authorization denial, timeout, stale task, malformed filters, and cancellation.
Migrate remaining callers incrementally and remove duplicate credential or retry logic.

Approval Boundaries

Do not conceal destructive index operations behind generic methods, silently retry writes, or migrate all callers without a compatibility and rollback plan.

Output

Return the call-site inventory, adapter API, trust boundaries, migrated callers, contract tests, preserved metadata, and remaining direct-client exceptions.

Error Handling

Condition	Response
Installed types differ from docs	Follow the lockfile and types; schedule version review separately.
Provider error is flattened	Preserve stat…

algolia-security-basics View full skill →

Audit and harden Algolia credentials, record exposure, index restrictions, and tenant search controls.

ReadGlobGrepWebFetchWriteEdit

Algolia Security Baseline

Overview

This skill reviews the actual security boundary of an Algolia integration. A browser search-only key is intentionally visible, so record contents, index restrictions, secured-key design, and abuse controls remain essential.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Never index data that must remain secret merely because an attribute is not displayed.
Use custom main keys with minimum ACLs and restrictions; rotate long-lived keys under an owned policy.
Generate secured keys on a trusted backend and require restrictions appropriate to the user or tenant.
Treat referer restrictions, rate limits, filters, and ACLs as layers whose current behavior must be verified.

Authentication

Inspect key metadata without exporting secret values. Admin credentials stay out of application defaults, browser bundles, logs, support artifacts, and developer examples.

Instructions

Inventory every application ID, environment variable, client constructor, key owner, ACL, restriction, and exposed index.
Scan source, built assets, history, logs, and documentation for write-capable key exposure.
Review record fields and index settings for data a search-only client could retrieve or scrape.
Map backend operations to custom key ACLs and tenant search to secured-key restrictions.
Test allowed and denied paths, including cross-index and cross-tenant attempts.
Document rotation, revocation, incident response, ownership, exceptions, and retest dates.

Approval Boundaries

Do not rotate or revoke production keys, alter index restrictions, or remove access until dependencies and recovery paths are verified.

Output

Return the key and actor inventory, exposure findings, data-visibility review, allowed/denied tests, remediation plan, rotation procedure, and residual risks.

Error Handling

Condition	Response
Write key found in browser	Contain and rotate through the incident process.
Search key exposes sensitive records	Remove …

algolia-upgrade-migration View full skill →

Migrate an Algolia JavaScript client integration from v4 to v5 with inventory, compatibility tests, and rollback.

ReadGlobGrepWebFetchWriteEdit

Algolia JavaScript v4 to v5 Upgrade

Overview

This skill follows the official v5 migration contract and the repository's pinned dependency graph. It treats import, method, parameter, response, wait, and test changes as one controlled migration.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Version 5 removes initIndex; methods live on the client and receive indexName.
Upgrade search-only imports and multi-search calls according to the official guide, not a mechanical rename.
Replace chained write waits with the documented v5 wait helpers and retain task IDs.
Check all Algolia packages, frameworks, wrappers, mocks, generated types, and examples for major-version coupling.

Authentication

Do not change key privilege during an SDK upgrade. Use existing least-privilege test credentials only for safe verification targets.

Instructions

Inventory package versions, imports, initIndex, client wrappers, methods, waits, mocks, and runtime targets.
Read the current official v5 migration guide and installed types for every used method.
Update the dependency and lockfile through the repository's package manager.
Migrate one boundary at a time, adapting parameters, responses, tasks, and errors.
Run type, unit, integration, build, and representative query tests; use a disposable index for writes.
Record compatibility gaps, final versions, release notes, rollback commit, and follow-up cleanup.

Approval Boundaries

Do not combine the SDK upgrade with relevance, index schema, credential, or broad architectural changes unless separately scoped and tested.

Output

Return the usage inventory, official mapping, dependency diff, migrated boundaries, test evidence, remaining v4 patterns, compatibility notes, and rollback.

Error Handling

Condition	Response
`initIndex` remains	Locate the call or generated artifact and migrate it.
Method signature differs	Follow installed v5 types and current off…

algolia-webhooks-events View full skill →

Implement and validate Algolia click, conversion, and view events while separating them from source-to-index synchronization.

ReadGlobGrepWebFetchWriteEdit

Algolia Search Events and Source Sync

Overview

This skill corrects a common category error: user interaction events go to the Insights API, while database or business events drive an application-owned indexing pipeline. These flows have different identity, delivery, privacy, and retry contracts.

Prerequisites

A named repository, environment, and Algolia application or index in scope
The local lockfile and installed client types as implementation authority
A safe read-only query or explicitly disposable test target
Current first-party documentation for any provider behavior that affects the change

Tool Discipline

Use Read, Glob, and Grep to inspect local code, configuration names, tests, and dependency versions. Use WebFetch only for current official Algolia documentation. Use Write or Edit only after identifying the target files, constraints, and verification plan.

Current Contract

Use the dedicated search-insights client or supported framework integration for browser events; it is not the Search API client.
Set clickAnalytics when a search-related event needs a returned query ID.
Use a stable pseudonymous user token and preserve query ID, object IDs, positions, and event names as required.
Design source-to-index updates as idempotent writes with ordering, dead-letter, replay, and reconciliation.

Authentication

Browser events use the documented Insights credential pattern and must not contain write-capable keys or personal identifiers. Index sync uses a separate restricted backend key.

Instructions

Classify the requested flow as user interaction telemetry, source-data synchronization, or both.
Map consent, user identity, query ID, object IDs, event taxonomy, and downstream feature consumers.
Implement events with the pinned search-insights or framework API and validate payloads using provider tooling.
Implement source sync separately with stable IDs, idempotency, bounded retry, dead-letter handling, and task waits.
Test missing query ID, duplicate delivery, consent denial, offline clients, reordered source events, and replay.
Measure event validity and index reconciliation, then document ownership and rollback.

Approval Boundaries

Do not send personal identifiers as user tokens, invent attribution when query IDs are absent, or treat interaction events as database webhooks.

Output

Return the flow classification, event and sync contracts, credential boundaries, validation results, retry and replay behavior, privacy decisions, and operational ownership.

Error Handling

…

Condition	Response

algolia-pack

Installation

What It Does

Skills (24) plugin-local skills

Algolia CI Integration

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Algolia Error Triage

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Algolia Search Contract

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Algolia Indexing Contract

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Algolia Usage and Cost Review

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Algolia Data Handling Review

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Algolia Redacted Debug Bundle

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Algolia Deployment Integration

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication