# Algolia

```json
{
  "name": "Algolia",
  "slug": "algolia",
  "url": "https://composio.dev/toolkits/algolia",
  "markdown_url": "https://composio.dev/toolkits/algolia.md",
  "logo_url": "https://logos.composio.dev/api/algolia",
  "categories": [
    "developer tools & devops"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-05-12T10:00:50.107Z"
}
```

![Algolia logo](https://logos.composio.dev/api/algolia)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Algolia MCP or direct API to search indexes, add or update records, delete entries, and analyze search performance through natural language.

## Summary

Algolia is a hosted search API that powers lightning-fast, relevant search experiences for web and mobile apps. It helps developers deliver instant, typo-tolerant, and scalable search without complex infrastructure.

## Categories

- developer tools & devops

## Toolkit Details

- Tools: 127

## Images

- Logo: https://logos.composio.dev/api/algolia

## Authentication

- **Api Key**
  - Type: `api_key`
  - Description: Api Key authentication for Algolia.
  - Setup:
    - Configure Api Key credentials for Algolia.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- Export all records from products index
- Clear all objects from blog_posts index
- Copy index settings from staging to production
- Create an AB test comparing two search configs

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `ALGOLIA_ADD_AB_TEST` | Add AB Test | Tool to create an A/B test comparing search performance between two index variants. Use when you need to test different search configurations, ranking strategies, or index settings and measure their impact on user behavior. |
| `ALGOLIA_ADD_OR_REPLACE_RECORD` | Add or Replace Record | Tool to add or replace a specific record in an index by objectID. If a record with the given objectID exists, it is replaced; otherwise, a new record is created. Use when you need to upsert an object with a known ID. |
| `ALGOLIA_ADD_RECORD` | Add Record to Index | Tool to add a record to an index with auto-generated objectID. Records with matching IDs are replaced. Use when you need to insert a new object into an index. |
| `ALGOLIA_BROWSE_INDEX` | Browse Algolia Index | Tool to retrieve all records from an index. Use when you need to export or iterate through an entire index dataset. |
| `ALGOLIA_CLEAR_OBJECTS` | Clear Objects | Tool to clear records of an index without affecting settings. Use when you need to completely wipe all objects (e.g., after a bulk reindex) while preserving index configuration. |
| `ALGOLIA_CLEAR_RULES` | Clear Rules | Tool to delete all rules in an index. Use when you need to wipe all rules before re-creating them. Use after confirming no critical rules require retention. |
| `ALGOLIA_CLEAR_SYNONYMS` | Clear Synonyms | Tool to delete all synonyms from an index. Use when you need to remove all synonym definitions in one operation. |
| `ALGOLIA_CLICKED_OBJECT_IDS` | Clicked Object IDs | Tool to send a click event to Algolia to capture clicked items. Use immediately after a user click outside of search contexts to report click events. |
| `ALGOLIA_CLICKED_OBJECT_IDS_AFTER_SEARCH` | Clicked Object IDs After Search | Tool to send a click event after a search response. Use when you want to report which items a user clicked in search results. |
| `ALGOLIA_CONVERTED_OBJECT_IDS` | Converted Object IDs | Tool to send a conversion event for items outside of search context. Use when tracking conversions on category pages or external flows unrelated to Algolia search. |
| `ALGOLIA_COPY_INDEX` | Copy Index | Tool to copy the specified index to a new index. Use when you need to duplicate an existing index including records, settings, synonyms, and rules after confirming source and destination names. |
| `ALGOLIA_CREATE_API_KEY` | Create API Key | Tool to create a new API key with specific permissions and restrictions. Use when you need to generate API keys with custom ACL permissions, index restrictions, rate limits, or expiration times. |
| `ALGOLIA_CREATE_AUTHENTICATION` | Create Authentication | Tool to create a new authentication resource in Algolia. Use when you need to set up authentication credentials for connecting to sources or destinations in the Algolia ingestion API. |
| `ALGOLIA_CREATE_DESTINATION` | Create Destination | Tool to create a new destination in Algolia Ingestion API. Use when you need to set up a new destination for data ingestion. |
| `ALGOLIA_CREATE_INGESTION_TASK` | Create Ingestion Task | Tool to create a new ingestion task connecting a source to a destination in Algolia. Use when you need to set up data synchronization between a source and an Algolia index. |
| `ALGOLIA_CREATE_OR_UPDATE_RECOMMEND_RULES` | Create or Update Recommend Rules | Tool to create or update a batch of Recommend Rules in an index. Use when you need to add or modify multiple rules at once for a recommendation model. Each rule is created or updated depending on whether a rule with the same objectID already exists. |
| `ALGOLIA_CREATE_QS_CONFIG` | Create Query Suggestions Config | Tool to create a new Query Suggestions configuration for an Algolia index. Use when you need to set up query suggestions to help users discover popular searches. Up to 100 configurations per application are supported. |
| `ALGOLIA_CREATE_SOURCE` | Create Source | Tool to create a new data source in Algolia Ingestion API. Use when you need to set up a new source for data ingestion from external platforms or custom data feeds. |
| `ALGOLIA_CREATE_TRANSFORMATION` | Create Transformation | Tool to create a new transformation in Algolia Ingestion API. Use when you need to set up data transformations for enriching or modifying records during ingestion. |
| `ALGOLIA_DELETE_AB_TEST` | Delete AB Test | Tool to delete an A/B test by its unique identifier. Use when you need to permanently remove an A/B test configuration. |
| `ALGOLIA_DELETE_API_KEY` | Delete API Key | Tool to delete an API key. Use when you need to revoke or remove an existing API key from your Algolia application. |
| `ALGOLIA_DELETE_AUTHENTICATION` | Delete Authentication | Tool to delete an authentication resource from Algolia. Use when you need to remove an existing authentication resource by its ID. |
| `ALGOLIA_DELETE_CONFIG` | Delete Query Suggestions Config | Tool to delete a Query Suggestions configuration for the specified index. Use when you need to remove a Query Suggestions configuration permanently. |
| `ALGOLIA_DELETE_DESTINATION` | Delete Destination | Tool to delete a destination in Algolia Ingestion API. Use when you need to permanently remove a destination by its ID. |
| `ALGOLIA_DELETE_INDEX` | Delete Index | Tool to delete the specified index and all its records. Use when you need to permanently remove an index after confirming it's no longer needed. |
| `ALGOLIA_DELETE_OBJECTS` | Delete Multiple Records | Tool to delete multiple records from an Algolia index. Use when you need to remove multiple objects by their IDs. |
| `ALGOLIA_DELETE_RECOMMEND_RULE` | Delete Recommend Rule | Tool to delete a Recommend rule from a recommendation scenario. Use when you need to remove a specific rule from an index's recommend model. |
| `ALGOLIA_DELETE_RECORDS_BY_FILTER` | Delete Records by Filter | Tool to delete records matching a filter from an Algolia index. Use when you need to remove multiple records based on filter criteria (e.g., category, tags, numeric ranges). This is a resource-intensive operation. |
| `ALGOLIA_DELETE_RULE` | Delete Rule | Tool to delete the specified rule from an index. Use when you need to permanently remove a rule after confirming its objectID. |
| `ALGOLIA_DELETE_SOURCE` | Delete Source | Tool to delete a source from the Algolia Ingestion API. Use when you need to permanently remove a source after confirming it's no longer needed. |
| `ALGOLIA_DELETE_SYNONYM` | Delete Synonym | Tool to delete a synonym from a specified index. Use when you need to remove an existing synonym by its objectID. |
| `ALGOLIA_DELETE_TRANSFORMATION` | Delete Transformation | Tool to delete a transformation in Algolia Ingestion API. Use when you need to permanently remove a transformation by its ID. |
| `ALGOLIA_DELETE_USER_PROFILE` | Delete User Profile | Tool to delete a user profile from personalization. Use when you need to remove a user's personalization data and reset their profile. |
| `ALGOLIA_DELETE_USER_TOKEN` | Delete User Token | Tool to delete all events related to a user token from events metrics and analytics. Use when removing user data from Algolia Insights. |
| `ALGOLIA_EXECUTE_BATCH_ON_MULTIPLE_INDICES` | Batch Operations on Multiple Indices | Tool to perform batch operations (add, update, delete) across multiple Algolia indices in a single request. Use when you need to modify records in different indices efficiently. Each operation specifies its target index and action type. |
| `ALGOLIA_EXPORT_RULES` | Export Rules | Tool to export all rules defined on an index. Use when you need to backup or migrate index rules. |
| `ALGOLIA_FIND_OBJECT` | Find Object | Tool to find the first object matching a query or filter in an index. Use when debugging relevance or filter logic after confirming index exists. |
| `ALGOLIA_GET_AB_TEST` | Get A/B Test | Tool to retrieve detailed information about an A/B test by its ID. Use when you need to check A/B test status, performance metrics, or configuration details. |
| `ALGOLIA_GET_ADD_TO_CART_RATE` | Get Add to Cart Rate | Tool to retrieve add-to-cart rate metrics for e-commerce search analytics. Use when you need to analyze conversion effectiveness and user purchasing behavior for an index, including daily breakdowns. |
| `ALGOLIA_GET_API_KEY` | Get API Key | Tool to retrieve the permissions and details of a specific API key. Use when you need to inspect an API key's ACL, restrictions, or other settings. |
| `ALGOLIA_GET_APP_TASK` | Get App Task Status | Tool to check the status of an application task. Use when you need to verify if a task has completed. |
| `ALGOLIA_GET_AUTHENTICATION` | Get Authentication | Tool to retrieve an authentication resource by its ID. Use when you need to fetch details about a specific authentication configuration in Algolia's ingestion API. |
| `ALGOLIA_GET_AVERAGE_CLICK_POSITION` | Get Average Click Position | Tool to retrieve average click position metrics from Algolia Analytics. Use when analyzing user engagement and click behavior for search results. |
| `ALGOLIA_GET_CLICK_POSITIONS` | Get Click Positions | Tool to retrieve the distribution of clicks by position from Algolia Analytics. Use when analyzing which search result positions receive the most user engagement. |
| `ALGOLIA_GET_CLICK_THROUGH_RATE` | Get Click Through Rate | Tool to retrieve click-through rate (CTR) for searches with at least one click event. Use when you need to analyze search effectiveness and user engagement metrics for an index, including daily breakdowns. |
| `ALGOLIA_GET_CONFIG` | Get Query Suggestions Config | Tool to retrieve a Query Suggestions configuration by index name. Use when you need to inspect or verify Query Suggestions settings for a specific index. |
| `ALGOLIA_GET_CONFIG2` | Get Personalization Config | Tool to retrieve the advanced personalization configuration. Use when you need to check personalization settings, re-ranking impact levels, or profile types for your Algolia application. |
| `ALGOLIA_GET_CONVERSION_RATE` | Get Conversion Rate | Tool to retrieve conversion rate for searches with conversion events. Use when you need to analyze conversion effectiveness and user behavior metrics for an index, including daily breakdowns. |
| `ALGOLIA_GET_DESTINATION` | Get Destination | Tool to retrieve a destination by its ID. Use when you need to get details about a specific Algolia destination resource. |
| `ALGOLIA_GET_DICTIONARY_LANGUAGES` | Get Dictionary Languages | Tool to list available languages for dictionary entries. Use when you need to check which languages support custom dictionary entries (plurals, stopwords, compounds). |
| `ALGOLIA_GET_DICTIONARY_SETTINGS` | Get Dictionary Settings | Tool to retrieve dictionary settings for all dictionaries. Use when you need to check which standard dictionary entries are disabled across different languages. |
| `ALGOLIA_GET_LOGS` | Get Logs | Tool to retrieve log entries for API requests made to your Algolia application. Use when you need to debug issues, monitor API usage, or analyze search patterns. |
| `ALGOLIA_GET_NO_CLICK_RATE` | Get No Click Rate | Tool to retrieve the rate of searches that received no clicks. Use when you need to analyze search effectiveness and identify queries where users didn't engage with any results. |
| `ALGOLIA_GET_NO_RESULTS_RATE` | Get No Results Rate | Tool to retrieve the fraction of searches that didn't return any results. Use when you need to analyze search effectiveness and identify queries that fail to return results. |
| `ALGOLIA_GET_NO_RESULTS_SEARCHES` | Get No Results Searches | Tool to retrieve the most frequent searches that produced zero results. Use when analyzing search gaps or identifying content opportunities to improve search experience. |
| `ALGOLIA_GET_OBJECT_POSITION` | Get Object Position | Tool to retrieve an object’s position in a result set. Use when debugging relevance after performing a search query. |
| `ALGOLIA_GET_OBJECTS` | Get multiple objects | Tool to retrieve multiple records from an index. Use when you need to batch-fetch several objectIDs in one call. |
| `ALGOLIA_GET_PURCHASE_RATE` | Get Purchase Rate | Tool to retrieve purchase rate metrics for searches that led to purchase events. Use when you need to analyze conversion effectiveness and purchase behavior for an index, including daily breakdowns. |
| `ALGOLIA_GET_RECOMMEND_RULE` | Get Recommend Rule | Tool to retrieve a Recommend rule that was previously created in the Algolia dashboard. Use when you need to inspect a specific rule's configuration, conditions, or consequences by its objectID. |
| `ALGOLIA_GET_RECOMMEND_TASK_STATUS` | Get Recommend Task Status | Tool to check the status of a Recommend task. Use when you need to verify if an asynchronous Recommend operation (such as deleting a Recommend rule) has completed. |
| `ALGOLIA_GET_RECORD` | Get Record from Index | Tool to retrieve a specific record from an index by its objectID. Use when you need to fetch a single object's details. |
| `ALGOLIA_GET_REVENUE` | Get Revenue | Tool to retrieve revenue data from Algolia Analytics. Use when analyzing revenue metrics and conversion tracking for search results. |
| `ALGOLIA_GET_RULE` | Get Rule | Tool to retrieve a specific rule by its objectID from an index. Use when you need to inspect a rule's configuration, conditions, and consequences. |
| `ALGOLIA_GET_SEARCHES_COUNT` | Get Searches Count | Tool to retrieve the number of searches within a time range, including a daily breakdown. Use when analyzing search volume and traffic patterns for an index. |
| `ALGOLIA_GET_SEARCHES_NO_CLICKS` | Get Searches No Clicks | Tool to retrieve top searches that did not receive any clicks. Use when analyzing search queries that may need optimization, such as queries with poor results or missing content. |
| `ALGOLIA_GET_SETTINGS` | Get Index Settings | Tool to retrieve the settings of a specified index. Use when you need to inspect index configurations after creation or update. |
| `ALGOLIA_GET_SOURCE` | Get Source | Tool to retrieve a source from the Algolia Ingestion API. Use when you need to get details about a specific data source by its ID. |
| `ALGOLIA_GET_SYNONYM` | Get Synonym | Tool to retrieve a specific synonym by its objectID. Use when you need to fetch details of an existing synonym from an index. |
| `ALGOLIA_GET_TASK_STATUS` | Get Task Status | Tool to check the status of an asynchronous task. Use when you need to verify completion of operations like adding or deleting records. |
| `ALGOLIA_GET_TOP_COUNTRIES` | Get Top Countries | Tool to retrieve top countries by search volume for a specified index. Use when you need to analyze geographic distribution of searches and understand where your users are searching from. |
| `ALGOLIA_GET_TOP_FILTER_ATTRIBUTES` | Get Top Filter Attributes | Tool to retrieve top filter attributes from Algolia Analytics. Use when analyzing which filters are most commonly used by users in searches. |
| `ALGOLIA_GET_TOP_FILTER_FOR_ATTRIBUTE` | Get Top Filter For Attribute | Tool to retrieve top filter values for a specific attribute from Algolia Analytics. Use when analyzing which filter values are most commonly used for a given attribute in search queries. |
| `ALGOLIA_GET_TOP_FILTERS_NO_RESULTS` | Get Top Filters No Results | Tool to retrieve top filters for searches that returned no results from Algolia Analytics. Use when analyzing which filters are commonly applied to searches that yield zero results, helping identify potential catalog or filtering issues. |
| `ALGOLIA_GET_TOP_HITS` | Get Top Hits | Tool to retrieve the object IDs of the most frequent search results from Algolia Analytics. Returns up to 1,000 top hits ranked by frequency, optionally including click analytics (CTR, conversion rates) and revenue metrics. Use when analyzing which results appear most often in searches. |
| `ALGOLIA_GET_TOP_SEARCHES` | Get Top Searches | Tool to retrieve the most popular searches from Algolia Analytics. Returns search queries ranked by frequency, optionally including click analytics (CTR, conversion rates) and revenue metrics. Use when analyzing search behavior and identifying trending queries. |
| `ALGOLIA_GET_TRANSFORMATION` | Get Transformation | Tool to retrieve a transformation by its ID from Algolia's Ingestion API. Use when you need to fetch details about a specific transformation including its code, configuration, and metadata. |
| `ALGOLIA_GET_USAGE` | Get Usage Statistics | Tool to retrieve Algolia usage statistics over a specified time period. Use when you need to analyze search operations, indexing operations, capacity metrics, or other usage data for an Algolia application. Requires Premium plan or Enterprise add-on access. |
| `ALGOLIA_GET_USAGE_FOR_INDEX` | Get Usage for Index | Tool to retrieve usage statistics for a specific Algolia index over a time period. Use when you need to analyze index metrics such as record counts, query volumes, processing times, or capacity usage. Supports both hourly and daily aggregation granularity. |
| `ALGOLIA_GET_USERS` | Get Users | Tool to retrieve a list of user profiles from Algolia advanced personalization. Use when you need to fetch user affinities, filter by date ranges, or paginate through user data. |
| `ALGOLIA_GET_USERS_COUNT` | Get Users Count | Tool to retrieve the number of unique users within a time range, including daily breakdown. Use when you need to analyze user engagement metrics for a specific index over a date range. |
| `ALGOLIA_INDEX_EXISTS` | Index Exists | Tool to check if an Algolia index exists. Use before performing index operations to prevent accidental index creation. Results are scoped to the Algolia app ID configured in the Composio connection. Example: IndexExists(index_name='products'). |
| `ALGOLIA_INIT_INSIGHTS` | Init Insights API Client | Tool to initialize the Algolia Insights API client. Use before sending any Insights events. |
| `ALGOLIA_LIST_AB_TESTS` | List AB Tests | Tool to list all A/B tests configured for this application. Use when you need to view existing A/B tests, check their status, or retrieve test IDs for further operations. |
| `ALGOLIA_LIST_API_KEYS` | List API Keys | Tool to list all API keys associated with your Algolia application, including their permissions and restrictions. Use when you need to audit API key usage, check permissions, or manage access control. |
| `ALGOLIA_LIST_AUTHENTICATIONS` | List Authentications | Tool to list authentication resources from Algolia. Use when you need to retrieve available authentication configurations for sources or destinations. |
| `ALGOLIA_LIST_DESTINATIONS` | List Destinations | Tool to list destinations in Algolia. Use when you need to retrieve all destinations or filter them by type, authentication ID, or transformation ID. |
| `ALGOLIA_LIST_INDICES` | List Indices | Tool to list all indices and their metadata. Use when you need to retrieve index names, sizes, and state before performing operations that depend on index properties. |
| `ALGOLIA_LIST_INGESTION_TASKS` | List Ingestion Tasks | Tool to retrieve a list of ingestion tasks from Algolia. Use when you need to fetch configured tasks for ingestion pipelines. Supports filtering by various criteria such as source, destination, trigger type, action, and enabled status, with pagination and sorting. |
| `ALGOLIA_LIST_QS_CONFIGS` | List Query Suggestions Configurations | Tool to retrieve all Query Suggestions configurations for an Algolia application. Use when you need to view or audit existing Query Suggestions setups. |
| `ALGOLIA_LIST_RUNS` | List Task Runs | Tool to list task runs. Use when you need to retrieve and monitor task execution status, filter by time range, or paginate through run history. |
| `ALGOLIA_LIST_SOURCES` | List Sources | Tool to list sources from the Algolia Ingestion API. Use when you need to retrieve available data sources for ingestion pipelines. Supports filtering by type and authentication ID, with pagination and sorting options. |
| `ALGOLIA_LIST_TRANSFORMATIONS` | List Transformations | Tool to list all transformations in Algolia Ingestion API. Use when you need to retrieve transformation configurations, filter by type, or paginate through transformation lists. |
| `ALGOLIA_PARTIAL_UPDATE_OBJECTS` | Partial Update Objects | Tool to partially update multiple records in the specified index. Use when you need to change only selected fields of many objects without replacing entire records. Use after confirming objectIDs and desired updates. |
| `ALGOLIA_PUSH_TASK` | Push Records to Task | Tool to push records to an Algolia task by task ID. Use when you need to send data to a configured ingestion task. Note: tasks with source type 'json' cannot use this endpoint. |
| `ALGOLIA_REPLACE_ALL_RULES` | Replace All Rules | Tool to push a new set of rules, erasing previous ones. Use when you need zero-downtime atomic replacement of all rules in an index. |
| `ALGOLIA_REPLACE_TASK` | Replace Task | Tool to fully replace a task in Algolia Ingestion API. Use when you need to completely update a task with new configuration, replacing all existing settings. |
| `ALGOLIA_RESTORE_API_KEY` | Restore API Key | Tool to restore a deleted API key within 72 hours of deletion. Use when you need to recover an accidentally deleted API key. |
| `ALGOLIA_SAVE_RULE` | Save Rule | Tool to create or replace a rule in an index. Use when you need to add merchandising rules, query modifications, or conditional search behavior. |
| `ALGOLIA_SAVE_SYNONYM` | Save Synonym | Tool to add or update a synonym in the specified index. Use when you need programmatic upsert of search synonyms after index creation. |
| `ALGOLIA_SAVE_SYNONYMS` | Save Synonyms | Tool to batch create or replace synonyms in an Algolia index. If a synonym with the objectID doesn't exist, Algolia adds a new one. Use when you need to add or update multiple synonyms at once. |
| `ALGOLIA_SEARCH_AUTHENTICATIONS` | Search Authentications | Tool to search for authentication resources by IDs in Algolia. Use when you need to retrieve multiple specific authentication configurations by their IDs. |
| `ALGOLIA_SEARCH_DESTINATIONS` | Search Destinations | Tool to search for specific destinations by their IDs. Use when you need to retrieve multiple destinations at once by providing their unique identifiers. |
| `ALGOLIA_SEARCH_DICTIONARY_ENTRIES` | Search Dictionary Entries | Tool to search dictionary entries in Algolia dictionaries. Use when you need to find stopwords, plurals, or compound words in specific dictionaries. |
| `ALGOLIA_SEARCH_FACET_VALUES` | Search Facet Values | Tool to search for values of a specified facet attribute. Use when you need to find specific facet values that match a query string. Facet values are sorted by decreasing count by default. |
| `ALGOLIA_SEARCH_INDEX` | Search Algolia Index | Tool to perform a search on a specified Algolia index. Use after confirming the index name. Example: SearchIndex(index_name='contacts', query='apple', search_params={'hitsPerPage':10}) |
| `ALGOLIA_SEARCH_MULTIPLE_INDICES` | Search Multiple Indices | Tool to perform searches across multiple indices in a single call. Use when you need to batch multiple index queries into one API request. |
| `ALGOLIA_SEARCH_RECOMMEND_RULES` | Search Recommend Rules | Tool to search for Recommend rules in the specified index and model. Use when you need to retrieve rules matching a query, or use an empty query to list all rules for this recommendation scenario. |
| `ALGOLIA_SEARCH_SOURCES` | Search Sources | Tool to search for sources by IDs in Algolia Ingestion API. Use when you need to retrieve multiple specific data sources by their IDs. |
| `ALGOLIA_SEARCH_SYNONYMS` | Search Synonyms | Tool to search for synonyms in the specified index. Use when you need to retrieve synonyms matching a query or filter by type. |
| `ALGOLIA_SEARCH_TRANSFORMATIONS` | Search Transformations | Tool to search for transformations by IDs in Algolia Ingestion API. Use when you need to retrieve multiple specific transformation configurations by their IDs. |
| `ALGOLIA_SET_DICTIONARY_SETTINGS` | Set Dictionary Settings | Tool to update dictionary settings for Algolia. Use when you need to enable or disable built-in stop words, plurals, or compounds for specific languages. |
| `ALGOLIA_SET_PERSONALIZATION_STRATEGY` | Set Personalization Strategy | Tool to define personalization strategy that controls how user behavior affects search results. Use when you need to configure which events and facets influence personalized search rankings. |
| `ALGOLIA_SET_SETTINGS` | Set Index Settings | Tool to update an Algolia index's settings. Use when you need to configure index behavior before indexing records. Example: set searchableAttributes and customRanking for products index. |
| `ALGOLIA_STOP_AB_TEST` | Stop AB Test | Tool to stop an A/B test by its unique identifier. Use when you need to halt an active A/B test. Note that stopped A/B tests cannot be restarted. |
| `ALGOLIA_TRY_TRANSFORMATION` | Try Transformation | Tool to try a transformation before creating it in Algolia. Use when you need to test transformation code or no-code configurations against sample data to verify they work correctly before deployment. |
| `ALGOLIA_TRY_TRANSFORMATION_BEFORE_UPDATE` | Try Transformation Before Update | Tool to test a transformation before updating it in Algolia Ingestion API. Use when you need to validate transformation code or configuration against sample data before applying it to production. |
| `ALGOLIA_UPDATE_API_KEY` | Update API Key | Tool to update the permissions and settings of an existing API key. Use when you need to modify ACL permissions, index restrictions, rate limits, or other settings of an existing API key. |
| `ALGOLIA_UPDATE_AUTHENTICATION` | Update Authentication | Tool to update an authentication resource in Algolia. Use when you need to modify the name or credentials of an existing authentication configuration. |
| `ALGOLIA_UPDATE_CONFIG` | Update Query Suggestions Config | Tool to update an existing Query Suggestions configuration. Use when you need to modify settings for query suggestions on an existing index. |
| `ALGOLIA_UPDATE_DESTINATION` | Update Destination | Tool to update a destination in Algolia Ingestion API. Use when you need to modify an existing destination's configuration, name, type, or associated transformations. |
| `ALGOLIA_UPDATE_DICTIONARY_ENTRIES` | Update Dictionary Entries | Tool to add or delete dictionary entries in Algolia dictionaries. Use when you need to batch modify stopwords, plurals, or compound word entries. |
| `ALGOLIA_UPDATE_RECORD_PARTIALLY` | Update Record Partially | Tool to add or update attributes in a single record. Use when you need to modify specific fields without replacing the entire record. Creates a new record if the objectID doesn't exist (when create_if_not_exists is true). |
| `ALGOLIA_UPDATE_SOURCE` | Update Source | Tool to update a source in the Algolia Ingestion API. Use when you need to modify the name, authentication, or input configuration of an existing data source. |
| `ALGOLIA_UPDATE_TASK` | Update Task | Tool to partially update a task in Algolia Ingestion API. Use when you need to modify task configuration such as schedule, failure threshold, destination, or notification settings. |
| `ALGOLIA_UPDATE_TRANSFORMATION` | Update Transformation | Tool to update an existing transformation in Algolia Ingestion API. Use when you need to modify transformation settings, code, or configuration for data processing during ingestion. |
| `ALGOLIA_VALIDATE_SOURCE` | Validate Source | Tool to validate a source payload before creating it in Algolia. Use when you need to verify that a source configuration is valid before actually creating the source. |
| `ALGOLIA_VALIDATE_SOURCE_BEFORE_UPDATE` | Validate Source Before Update | Tool to validate a source update payload in the Algolia Ingestion API. Use when you need to verify that an update to a source configuration is valid before actually updating it. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK
```python
pip install composio_openai
```

```typescript
npm install @composio/openai
```

#### Path 1, Step 2: Initialize Composio and Create Tool Router Session

Import and initialize Composio client, then create a Tool Router session
```python
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
openai = OpenAI()
session = composio.create(user_id='your-user-id')
```

```typescript
import OpenAI from 'openai';
import { Composio } from '@composio/core';
import { OpenAIResponsesProvider } from '@composio/openai';

const composio = new Composio({
  provider: new OpenAIResponsesProvider(),
});
const openai = new OpenAI({});
const session = await composio.create('your-user-id');
```

#### Path 1, Step 3: Execute Algolia Tools via Tool Router with Your Agent

Get tools from Tool Router session and execute Algolia actions with your Agent
```python
tools = session.tools
response = openai.responses.create(
  model='gpt-4.1',
  tools=tools,
  input=[{
    'role': 'user',
    'content': 'Browse all records from the products index'
  }]
)
result = composio.provider.handle_tool_calls(
  response=response,
  user_id='your-user-id'
)
print(result)
```

```typescript
const tools = session.tools;
const response = await openai.responses.create({
  model: 'gpt-4.1',
  tools: tools,
  input: [{
    role: 'user',
    content: 'Browse all records from the products index'
  }],
});
const result = await composio.provider.handleToolCalls(
  'your-user-id',
  response.output
);
console.log(result);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK and Claude Agent SDK
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/openai @ai-sdk/mcp
```

#### Path 2, Step 2: Create Tool Router Session

Initialize the Composio client and create a Tool Router session
```python
from composio import Composio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

composio = Composio(api_key='your-composio-api-key')
session = composio.create(user_id='your-user-id')
url = session.mcp.url
```

```typescript
import { Composio } from '@composio/core';

const composio = new Composio({ apiKey: 'your-api-key' });

console.log("Creating Tool Router session...");
const { mcp } = await composio.create('your-user-id');
console.log(`Tool Router session created: ${mcp.url}`);
```

#### Path 2, Step 3: Connect to AI Agent

Use the MCP server with your AI agent
```python
import asyncio

options = ClaudeAgentOptions(
    permission_mode='bypassPermissions',
    mcp_servers={
        'tool_router': {
            'type': 'http',
            'url': url,
            'headers': {
                'x-api-key': 'your-composio-api-key'
            }
        }
    },
    system_prompt='You are a helpful assistant with access to Algolia tools.',
    max_turns=10
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query('Browse all records in the products index')
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { openai } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText, stepCountIs } from 'ai';

const client = await createMCPClient({
  transport: {
    type: 'http',
    url: mcp.url,
    headers: { 'x-api-key': 'your-composio-api-key' }
  }
});

const tools = await client.tools();

const { text } = await generateText({
  model: openai('gpt-4o'),
  tools,
  messages: [{ role: 'user', content: 'Browse all records in the products index' }],
  stopWhen: stepCountIs( 5 )
});

console.log(`Agent: ${text}`);
```

## Why Use Composio?

### 1. AI Native Algolia Integration

- Supports both Algolia MCP and direct API based integrations
- Structured, LLM-friendly schemas for reliable tool execution
- Rich coverage for reading, writing, and querying your Algolia data

### 2. Managed Auth

- Built-in OAuth handling with automatic token refresh and rotation
- Central place to manage, scope, and revoke Algolia access
- Per user and per environment credentials instead of hard-coded keys

### 3. Agent Optimized Design

- Tools are tuned using real error and success rates to improve reliability over time
- Comprehensive execution logs so you always know what ran, when, and on whose behalf

### 4. Enterprise Grade Security

- Fine-grained RBAC so you control which agents and users can access Algolia
- Scoped, least privilege access to Algolia resources
- Full audit trail of agent actions to support review and compliance

## Use Algolia with any AI Agent Framework

Choose a framework you want to connect Algolia with:

- [OpenAI Agents SDK](https://composio.dev/toolkits/algolia/framework/open-ai-agents-sdk)
- [Claude Agent SDK](https://composio.dev/toolkits/algolia/framework/claude-agents-sdk)
- [Claude Code](https://composio.dev/toolkits/algolia/framework/claude-code)
- [Claude Cowork](https://composio.dev/toolkits/algolia/framework/claude-cowork)
- [Codex](https://composio.dev/toolkits/algolia/framework/codex)
- [OpenClaw](https://composio.dev/toolkits/algolia/framework/openclaw)
- [Hermes](https://composio.dev/toolkits/algolia/framework/hermes-agent)
- [Google ADK](https://composio.dev/toolkits/algolia/framework/google-adk)
- [LangChain](https://composio.dev/toolkits/algolia/framework/langchain)
- [Vercel AI SDK](https://composio.dev/toolkits/algolia/framework/ai-sdk)
- [Mastra AI](https://composio.dev/toolkits/algolia/framework/mastra-ai)
- [LlamaIndex](https://composio.dev/toolkits/algolia/framework/llama-index)
- [CrewAI](https://composio.dev/toolkits/algolia/framework/crew-ai)
- [Pydantic AI](https://composio.dev/toolkits/algolia/framework/pydantic-ai)
- [AutoGen](https://composio.dev/toolkits/algolia/framework/autogen)

## Related Toolkits

- [Supabase](https://composio.dev/toolkits/supabase) - Supabase is an open-source backend platform offering scalable Postgres databases, authentication, storage, and real-time APIs. It lets developers build modern apps without managing infrastructure.
- [Codeinterpreter](https://composio.dev/toolkits/codeinterpreter) - Codeinterpreter is a Python-based coding environment with built-in data analysis and visualization. It lets you instantly run scripts, plot results, and prototype solutions inside supported platforms.
- [GitHub](https://composio.dev/toolkits/github) - GitHub is a code hosting platform for version control and collaborative software development. It streamlines project management, code review, and team workflows in one place.
- [Ably](https://composio.dev/toolkits/ably) - Ably is a real-time messaging platform for live chat and data sync in modern apps. It offers global scale and rock-solid reliability for seamless, instant experiences.
- [Abuselpdb](https://composio.dev/toolkits/abuselpdb) - Abuselpdb is a central database for reporting and checking IPs linked to malicious online activity. Use it to quickly identify and report suspicious or abusive IP addresses.
- [Alchemy](https://composio.dev/toolkits/alchemy) - Alchemy is a blockchain development platform offering APIs and tools for Ethereum apps. It simplifies building and scaling Web3 projects with robust infrastructure.
- [Anchor browser](https://composio.dev/toolkits/anchor_browser) - Anchor browser is a developer platform for AI-powered web automation. It transforms complex browser actions into easy API endpoints for streamlined web interaction.
- [Apiflash](https://composio.dev/toolkits/apiflash) - Apiflash is a website screenshot API for programmatically capturing web pages. It delivers high-quality screenshots on demand for automation, monitoring, or reporting.
- [Apiverve](https://composio.dev/toolkits/apiverve) - Apiverve delivers a suite of powerful APIs that simplify integration for developers. It's designed for reliability and scalability so you can build faster, smarter applications without the integration headache.
- [Appcircle](https://composio.dev/toolkits/appcircle) - Appcircle is an enterprise-grade mobile CI/CD platform for building, testing, and publishing mobile apps. It streamlines mobile DevOps so teams ship faster and with more confidence.
- [Appdrag](https://composio.dev/toolkits/appdrag) - Appdrag is a cloud platform for building websites, APIs, and databases with drag-and-drop tools and code editing. It accelerates development and iteration by combining hosting, database management, and low-code features in one place.
- [Appveyor](https://composio.dev/toolkits/appveyor) - AppVeyor is a cloud-based continuous integration service for building, testing, and deploying applications. It helps developers automate and streamline their software delivery pipelines.
- [Backendless](https://composio.dev/toolkits/backendless) - Backendless is a backend-as-a-service platform for mobile and web apps, offering database, file storage, user authentication, and APIs. It helps developers ship scalable applications faster without managing server infrastructure.
- [Baserow](https://composio.dev/toolkits/baserow) - Baserow is an open-source no-code database platform for building collaborative data apps. It makes it easy for teams to organize data and automate workflows without writing code.
- [Bench](https://composio.dev/toolkits/bench) - Bench is a benchmarking tool for automated performance measurement and analysis. It helps you quickly evaluate, compare, and track your systems or workflows.
- [Better stack](https://composio.dev/toolkits/better_stack) - Better Stack is a monitoring, logging, and incident management solution for apps and services. It helps teams ensure application reliability and performance with real-time insights.
- [Bitbucket](https://composio.dev/toolkits/bitbucket) - Bitbucket is a Git-based code hosting and collaboration platform for teams. It enables secure repository management and streamlined code reviews.
- [Blazemeter](https://composio.dev/toolkits/blazemeter) - Blazemeter is a continuous testing platform for web and mobile app performance. It empowers teams to automate and analyze large-scale tests with ease.
- [Blocknative](https://composio.dev/toolkits/blocknative) - Blocknative delivers real-time mempool monitoring and transaction management for public blockchains. Instantly track pending transactions and optimize blockchain interactions with live data.
- [Bolt iot](https://composio.dev/toolkits/bolt_iot) - Bolt IoT is a platform for building and managing IoT projects with cloud-based device control and monitoring. It makes connecting sensors and actuators to the internet seamless for automation and data insights.

## Frequently Asked Questions

### Do I need my own developer credentials to use Algolia with Composio?

Yes, Algolia requires you to configure your own API key credentials. Once set up, Composio handles secure credential storage and API request handling for you.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)