How to integrate Algolia MCP with LlamaIndex

Connect LlamaIndex to Algolia MCP. Export all records from products index, clear all objects from blog_posts index, and more using natural language, with authentication handled for you.

Algolia logoAlgolia
Api Key

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.

127 Tools

Introduction

This guide walks you through connecting Algolia to LlamaIndex using the Composio tool router. By the end, you'll have a working Algolia agent that can search your indices, add and update records, configure synonyms and rules, run A/B tests, and review search analytics through natural language commands.

This guide will help you understand how to give your LlamaIndex agent real control over a Algolia account through Composio's Algolia MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

For exact tool slugs and parameter tables, see the tool catalog in the Composio docs.

Also integrate Algolia with

TL;DR

Here's what you'll learn:
  • Set your OpenAI and Composio API keys
  • Install LlamaIndex and Composio packages
  • Create a Composio Tool Router session for Algolia
  • Connect LlamaIndex to the Algolia MCP server
  • Build a Algolia-powered agent using LlamaIndex
  • Interact with Algolia through natural language

What is LlamaIndex?

LlamaIndex is a data framework for building LLM applications. It provides tools for connecting LLMs to external data sources and services through agents and tools.

Key features include:

  • ReAct Agent: Reasoning and acting pattern for tool-using agents
  • MCP Tools: Native support for Model Context Protocol
  • Context Management: Maintain conversation context across interactions
  • Async Support: Built for async/await patterns

What is the Algolia MCP server, and what's possible with it?

The Algolia MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Algolia account. It provides structured and secure access to your search indexes, records, ingestion resources, tests, and analytics events, so your agent can find records, update index content, configure ingestion, manage tests, and record user interactions on your behalf.

  • Index and record management: Have your agent browse indexes, find and retrieve records, add or replace content, delete matching records, copy indexes, or run batch operations across multiple indexes.
  • Search testing and configuration: Let the agent create, inspect, and delete A/B tests, manage query suggestion configurations, and create or update recommendation rules.
  • Ingestion setup: Direct your agent to create and manage data sources, destinations, transformations, and ingestion tasks that move content into Algolia.
  • Rules and synonyms cleanup: Instruct your agent to export search rules, remove selected rules or synonyms, or clear all rules and synonyms from an index.
  • Analytics event tracking: Have your agent record clicked items, clicks following searches, and conversion events for items outside a search context.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step10 STEPS
1

Prerequisites

Before you begin, make sure you have:
  • Python 3.8/Node 16 or higher installed
  • A Composio account with the API key
  • An OpenAI API key
  • A Algolia account and project
  • Basic familiarity with async Python/Typescript
2

Getting API Keys for OpenAI, Composio, and Algolia

OpenAI API key (OPENAI_API_KEY)
  • Go to the OpenAI dashboard
  • Create an API key if you don't have one
  • Assign it to OPENAI_API_KEY in .env
Composio API key and user ID
  • Log into the Composio dashboard
  • Copy your API key from Settings
    • Use this as COMPOSIO_API_KEY
  • Pick a stable user identifier (email or ID)
    • Use this as COMPOSIO_USER_ID
3

Installing dependencies

npm install @composio/llamaindex @llamaindex/openai @llamaindex/tools @llamaindex/workflow dotenv

Create a new Typescript project and install the necessary dependencies:

  • @composio/llamaindex: Composio's LlamaIndex integration
  • @llamaindex/openai: OpenAI LLM integration
  • @llamaindex/tools: MCP client for LlamaIndex
  • @llamaindex/workflow: Workflow framework for LlamaIndex
  • dotenv: Environment variable management
4

Set environment variables

bash
OPENAI_API_KEY=your-openai-api-key
COMPOSIO_API_KEY=your-composio-api-key
COMPOSIO_USER_ID=your-user-id

Create a .env file in your project root:

These credentials will be used to:

  • Authenticate with OpenAI's GPT-5 model
  • Connect to Composio's Tool Router
  • Identify your Composio user session for Algolia access
5

Import modules

import "dotenv/config";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

import { Composio } from "@composio/core";

import { mcp } from "@llamaindex/tools";
import { agent as createAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";

dotenv.config();

Create a new file called algolia_llamaindex_agent.ts and import the required modules:

Key imports:

  • dotenv.config loads .env at runtime
  • readline gives us a simple CLI chat loop
  • Composio is the main Composio SDK client
  • mcp connects to an MCP endpoint
  • createAgent builds a LlamaIndex agent
  • openai configures the LLM backend
6

Load environment variables and initialize Composio

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const COMPOSIO_API_KEY = process.env.COMPOSIO_API_KEY;
const COMPOSIO_USER_ID = process.env.COMPOSIO_USER_ID;

if (!OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set");
if (!COMPOSIO_API_KEY) throw new Error("COMPOSIO_API_KEY is not set");
if (!COMPOSIO_USER_ID) throw new Error("COMPOSIO_USER_ID is not set");

What's happening:

This ensures missing credentials cause early, clear errors before the agent attempts to initialise.

7

Create a Tool Router session and build the agent function

async function buildAgent() {

  console.log(`Initializing Composio client...${COMPOSIO_USER_ID!}...`);
  console.log(`COMPOSIO_USER_ID: ${COMPOSIO_USER_ID!}...`);

  const composio = new Composio({
    apiKey: COMPOSIO_API_KEY,
    provider: new LlamaindexProvider(),
  });

  const session = await composio.create(
    COMPOSIO_USER_ID!,
    {
      toolkits: ["algolia"],
    },
  );

  const mcpUrl = session.mcp.url;
  console.log(`Composio Tool Router MCP URL: ${mcpUrl}`);

  const server = mcp({
    url: mcpUrl,
    clientName: "composio_tool_router_with_llamaindex",
    requestInit: {
      headers: {
        "x-api-key": COMPOSIO_API_KEY!,
      },
    },
    // verbose: true,
  });

  const tools = await server.tools();

  const llm = openai({ apiKey: OPENAI_API_KEY, model: "gpt-5" });

  const agent = createAgent({
    name: "composio_tool_router_with_llamaindex",
        description : "An agent that uses Composio Tool Router MCP tools to perform actions.",
    systemPrompt:
      "You are a helpful assistant connected to Composio Tool Router."+
"Use the available tools to answer user queries and perform Algolia actions." ,
    llm,
    tools,
  });

  return agent;
}

What's happening here:

  • We create a Composio client using your API key and configure it with the LlamaIndex provider
  • We then create a tool router MCP session for your user, specifying the toolkits we want to use (in this case, algolia)
  • The session returns an MCP HTTP endpoint URL that acts as a gateway to all your configured tools
  • LlamaIndex will connect to this endpoint to dynamically discover and use the available Algolia tools.
  • The MCP tools are mapped to LlamaIndex-compatible tools and plug them into the Agent.
8

Create an interactive chat loop

async function chatLoop(agent: ReturnType<typeof createAgent>) {
  const rl = readline.createInterface({ input, output });

  console.log("Type 'quit' or 'exit' to stop.");

  while (true) {
    let userInput: string;

    try {
      userInput = (await rl.question("\nYou: ")).trim();
    } catch {
      console.log("\nAgent: Bye!");
      break;
    }

    if (!userInput) {
      continue;
    }

    const lower = userInput.toLowerCase();
    if (lower === "quit" || lower === "exit") {
      console.log("Agent: Bye!");
      break;
    }

    try {
      process.stdout.write("Agent: ");

      const stream = agent.runStream(userInput);
      let finalResult: any = null;

      for await (const event of stream) {
        // The event.data contains the streamed content
        const data: any = event.data;

        // Check for streaming delta content
        if (data?.delta) {
          process.stdout.write(data.delta);
        }

        // Store final result for fallback
        if (data?.result || data?.message) {
          finalResult = data;
        }
      }

      // If no streaming happened, show the final result
      if (finalResult) {
        const answer =
          finalResult.result ??
          finalResult.message?.content ??
          finalResult.message ??
          "";
        if (answer && typeof answer === "string" && !answer.includes("[object")) {
          process.stdout.write(answer);
        }
      }

      console.log(); // New line after streaming completes
    } catch (err: any) {
      console.error("\nAgent error:", err?.message ?? err);
    }
  }

  rl.close();
}

What's happening:

  • We're creating a direct terminal interface to chat with Algolia
  • The LLM's responses are streamed to the CLI for faster interaction.
  • The agent uses context to maintain conversation history
  • The agent processes the request, selects appropriate Algolia tools, and returns a result
  • We extract the answer from the result data structure and display it to the user
  • You can type 'quit' or 'exit' to stop the chat loop gracefully
  • Agent responses and any errors are streamed in a clear, readable format
9

Define the main entry point

async function main() {
  try {
    const agent = await buildAgent();
    await chatLoop(agent);
  } catch (err) {
    console.error("Failed to start agent:", err);
    process.exit(1);
  }
}

main();

What's happening here:

  • We're orchestrating the entire application flow
  • The agent gets built with proper error handling
  • Then we kick off the interactive chat loop so you can start talking to Algolia
10

Run the agent

npx ts-node llamaindex-agent.ts

When prompted, authenticate and authorise your agent with Algolia, then start asking questions.

Complete Code

Here's the complete code to get you started with Algolia and LlamaIndex:

import "dotenv/config";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

import { Composio } from "@composio/core";
import { LlamaindexProvider } from "@composio/llamaindex";

import { mcp } from "@llamaindex/tools";
import { agent as createAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";

dotenv.config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const COMPOSIO_API_KEY = process.env.COMPOSIO_API_KEY;
const COMPOSIO_USER_ID = process.env.COMPOSIO_USER_ID;

if (!OPENAI_API_KEY) {
    throw new Error("OPENAI_API_KEY is not set in the environment");
  }
if (!COMPOSIO_API_KEY) {
    throw new Error("COMPOSIO_API_KEY is not set in the environment");
  }
if (!COMPOSIO_USER_ID) {
    throw new Error("COMPOSIO_USER_ID is not set in the environment");
  }

async function buildAgent() {

  console.log(`Initializing Composio client...${COMPOSIO_USER_ID!}...`);
  console.log(`COMPOSIO_USER_ID: ${COMPOSIO_USER_ID!}...`);

  const composio = new Composio({
    apiKey: COMPOSIO_API_KEY,
    provider: new LlamaindexProvider(),
  });

  const session = await composio.create(
    COMPOSIO_USER_ID!,
    {
      toolkits: ["algolia"],
    },
  );

  const mcpUrl = session.mcp.url;
  console.log(`Composio Tool Router MCP URL: ${mcpUrl}`);

  const server = mcp({
    url: mcpUrl,
    clientName: "composio_tool_router_with_llamaindex",
    requestInit: {
      headers: {
        "x-api-key": COMPOSIO_API_KEY!,
      },
    },
    // verbose: true,
  });

  const tools = await server.tools();

  const llm = openai({ apiKey: OPENAI_API_KEY, model: "gpt-5" });

  const agent = createAgent({
    name: "composio_tool_router_with_llamaindex",
    description:
      "An agent that uses Composio Tool Router MCP tools to perform actions.",
    systemPrompt:
      "You are a helpful assistant connected to Composio Tool Router."+
"Use the available tools to answer user queries and perform Algolia actions." ,
    llm,
    tools,
  });

  return agent;
}

async function chatLoop(agent: ReturnType<typeof createAgent>) {
  const rl = readline.createInterface({ input, output });

  console.log("Type 'quit' or 'exit' to stop.");

  while (true) {
    let userInput: string;

    try {
      userInput = (await rl.question("\nYou: ")).trim();
    } catch {
      console.log("\nAgent: Bye!");
      break;
    }

    if (!userInput) {
      continue;
    }

    const lower = userInput.toLowerCase();
    if (lower === "quit" || lower === "exit") {
      console.log("Agent: Bye!");
      break;
    }

    try {
      process.stdout.write("Agent: ");

      const stream = agent.runStream(userInput);
      let finalResult: any = null;

      for await (const event of stream) {
        // The event.data contains the streamed content
        const data: any = event.data;

        // Check for streaming delta content
        if (data?.delta) {
          process.stdout.write(data.delta);
        }

        // Store final result for fallback
        if (data?.result || data?.message) {
          finalResult = data;
        }
      }

      // If no streaming happened, show the final result
      if (finalResult) {
        const answer =
          finalResult.result ??
          finalResult.message?.content ??
          finalResult.message ??
          "";
        if (answer && typeof answer === "string" && !answer.includes("[object")) {
          process.stdout.write(answer);
        }
      }

      console.log(); // New line after streaming completes
    } catch (err: any) {
      console.error("\nAgent error:", err?.message ?? err);
    }
  }

  rl.close();
}

async function main() {
  try {
    const agent = await buildAgent();
    await chatLoop(agent);
  } catch (err: any) {
    console.error("Failed to start agent:", err?.message ?? err);
    process.exit(1);
  }
}

main();

Conclusion

You've successfully connected Algolia to LlamaIndex through Composio's Tool Router MCP layer. Key takeaways:
  • Tool Router dynamically exposes Algolia tools through an MCP endpoint
  • LlamaIndex's ReActAgent handles reasoning and orchestration; Composio handles integrations
  • The agent becomes more capable without increasing prompt size
  • Async Python provides clean, efficient execution of agent workflows
You can easily extend this to other toolkits like Gmail, Notion, Stripe, GitHub, and more by adding them to the toolkits parameter.
TOOLS

Supported Tools

Every Algolia action and event your agent gets out of the box.

Add AB Test

Tool to create an A/B test comparing search performance between two index variants.

Add or Replace Record

Tool to add or replace a specific record in an index by objectID.

Add Record to Index

Tool to add a record to an index with auto-generated objectID.

Browse Algolia Index

Browse a batch of records in an Algolia index, optionally filtering them by query or browse parameters.

Clear Objects

Tool to clear records of an index without affecting settings.

Clear Rules

Clear all rules from an Algolia index, optionally forwarding the operation to replica indices.

Clear Synonyms

Clear all synonyms from an Algolia index, optionally forwarding the operation to replica indices.

Clicked Object IDs

Tool to send a click event to Algolia to capture clicked items.

Clicked Object IDs After Search

Tool to send a click event after a search response.

Converted Object IDs

Tool to send a conversion event for items outside of search context.

Copy Index

Initiate an index copy and return an asynchronous task ID.

Create API Key

Tool to create a new API key with specific permissions and restrictions.

Create Authentication

Create an authentication resource in the US region of Algolia's ingestion API for connecting to sources or destinations.

Create Destination

Create a destination for data ingestion using the US Algolia Ingestion API endpoint.

Create Ingestion Task

Create an ingestion task connecting a source to a destination for data synchronization with an Algolia index.

Create or Update Recommend Rules

Tool to create or update a batch of Recommend Rules in an index.

Create Query Suggestions Config

Tool to create a new Query Suggestions configuration for an Algolia index.

Create Source

Tool to create a new data source in Algolia Ingestion API.

Create Transformation

Tool to create a new transformation in Algolia Ingestion API.

Delete AB Test

Tool to delete an A/B test by its unique identifier.

Delete API Key

Delete an Algolia API key to revoke access.

Delete Authentication

Delete an Algolia ingestion authentication resource by ID in the US region.

Delete Query Suggestions Config

Tool to delete a Query Suggestions configuration for the specified index.

Delete Destination

Delete a destination by ID using the US Algolia Ingestion API endpoint.

Delete Index

Tool to delete the specified index and all its records.

Delete Multiple Records

Tool to delete multiple records from an Algolia index.

Delete Recommend Rule

Tool to delete a Recommend rule from a recommendation scenario.

Delete Records by Filter

Tool to delete records matching a filter from an Algolia index.

Delete Rule

Tool to delete the specified rule from an index.

Delete Source

Delete an Algolia Ingestion API source by ID.

Delete Synonym

Tool to delete a synonym from a specified index.

Delete Transformation

Tool to delete a transformation in Algolia Ingestion API.

Delete User Profile

Tool to delete a user profile from personalization.

Delete User Token

Delete events related to a user token from Algolia Insights event metrics and analytics using the US Insights endpoint.

Batch Operations on Multiple Indices

Tool to perform batch operations (add, update, delete) across multiple Algolia indices in a single request.

Export Rules

Export a page of rules from an Algolia index for backup or migration.

Find Object

Tool to find the first object matching a query or filter in an index.

Get A/B Test

Retrieve an A/B test by ID from the DE analytics region, including its status, performance metrics, and configuration details.

Get Add to Cart Rate

Tool to retrieve add-to-cart rate metrics for e-commerce search analytics.

Get API Key

Tool to retrieve the permissions and details of a specific API key.

Get App Task Status

Tool to check the status of an application task.

Get Authentication

Tool to retrieve an authentication resource by its ID.

Get Average Click Position

Tool to retrieve average click position metrics from Algolia Analytics.

Get Click Positions

Tool to retrieve the distribution of clicks by position from Algolia Analytics.

Get Click Through Rate

Tool to retrieve click-through rate (CTR) for searches with at least one click event.

Get Query Suggestions Config

Tool to retrieve a Query Suggestions configuration by index name.

Get Personalization Config

Retrieve the advanced personalization configuration from the EU endpoint, including personalization settings, re-ranking impact and profile type.

Get Conversion Rate

Retrieve conversion rate analytics for an index from the US analytics endpoint, including daily breakdowns.

Get Destination

Retrieve an Algolia ingestion destination by ID using the US endpoint.

Get Dictionary Languages

Tool to list available languages for dictionary entries.

Get Dictionary Settings

Tool to retrieve dictionary settings for all dictionaries.

Get Logs

Tool to retrieve log entries for API requests made to your Algolia application.

Get No Click Rate

Retrieve aggregate and daily no-click rates for tracked searches on an index, with optional date and tag filters.

Get No Results Rate

Retrieve aggregate and daily no-results rates for an index using the US analytics endpoint.

Get No Results Searches

Retrieve frequent searches that produced zero results for an index using the US analytics endpoint.

Get Object Position

Find an object’s zero-based position by objectID in the hits of a supplied search response.

Get multiple objects

Tool to retrieve multiple records from an index.

Get Purchase Rate

Retrieve purchase rate metrics for an index, including daily breakdowns, from the US analytics region.

Get Recommend Rule

Tool to retrieve a Recommend rule that was previously created in the Algolia dashboard.

Get Recommend Task Status

Tool to check the status of a Recommend task.

Get Record from Index

Tool to retrieve a specific record from an index by its objectID.

Get Revenue

Retrieve search-related revenue data from Algolia Analytics using the US regional endpoint.

Get Rule

Tool to retrieve a specific rule by its objectID from an index.

Get Searches Count

Retrieve search counts for an index over a time range, including a daily breakdown, using the US regional Analytics endpoint.

Get Searches No Clicks

Retrieve top searches without clicks from Algolia Analytics using the US regional endpoint, to help identify queries that may need optimization.

Get Index Settings

Retrieve selected settings for a specified Algolia index to inspect its configuration.

Get Source

Tool to retrieve a source from the Algolia Ingestion API.

Get Synonym

Tool to retrieve a specific synonym by its objectID.

Get Task Status

Tool to check the status of an asynchronous task.

Get Top Countries

Retrieve top countries by search volume for a specified index using the US analytics endpoint, to analyze the geographic distribution of searches.

Get Top Filter Attributes

Tool to retrieve top filter attributes from Algolia Analytics.

Get Top Filter For Attribute

Tool to retrieve top filter values for a specific attribute from Algolia Analytics.

Get Top Filters No Results

Tool to retrieve top filters for searches that returned no results from Algolia Analytics.

Get Top Hits

Tool to retrieve the object IDs of the most frequent search results from Algolia Analytics.

Get Top Searches

Retrieve popular search queries from Algolia Analytics, with optional click analytics and revenue metrics.

Get Transformation

Tool to retrieve a transformation by its ID from Algolia's Ingestion API.

Get Usage Statistics

Tool to retrieve Algolia usage statistics over a specified time period.

Get Usage for Index

Retrieve usage statistics for a specific Algolia index over a time period, with hourly or daily aggregation, including metrics such as record counts, query volumes, and processing times.

Get Users

Retrieve user profiles and affinities from Algolia advanced personalization using the EU endpoint.

Get Users Count

Retrieve the number of unique users for an index over a time range, including a daily breakdown, using the US Algolia Analytics endpoint.

Index Exists

Tool to check if an Algolia index exists.

Init Insights API Client

Return Insights client configuration for a selected region, including the application ID, API key, host, and cookie-setting metadata.

List AB Tests

List a page of A/B tests for the application in the DE analytics region, with optional index prefix or suffix filters.

List API Keys

List the application's main API keys with their permissions and restrictions for access-control review.

List Authentications

List a page of Algolia ingestion authentication resources in the US region, with optional type and platform filters.

List Destinations

List a page of Algolia ingestion destinations using the US endpoint, optionally filtering by type, authentication ID or transformation ID.

List Indices

Tool to list all indices and their metadata.

List Ingestion Tasks

List ingestion tasks using the US ingestion endpoint.

List Query Suggestions Configurations

Tool to retrieve all Query Suggestions configurations for an Algolia application.

List Task Runs

List Algolia Ingestion task runs using the US regional endpoint.

List Sources

Tool to list sources from the Algolia Ingestion API.

List Transformations

Tool to list all transformations in Algolia Ingestion API.

Partial Update Objects

Partially update multiple records in an index by objectID without replacing entire records.

Push Records to Task

Push records and a selected indexing action to a configured ingestion task by task ID, including actions to delete records, clear an index, or delete an index.

Replace All Rules

Batch save rules in an index, replacing existing rules by default.

Replace Task

Replace an Algolia Ingestion task with new configuration using the US regional API endpoint.

Restore API Key

Tool to restore a deleted API key within 72 hours of deletion.

Save Rule

Tool to create or replace a rule in an index.

Save Synonym

Tool to add or update a synonym in the specified index.

Save Synonyms

Batch create or replace synonyms in an Algolia index.

Search Authentications

Tool to search for authentication resources by IDs in Algolia.

Search Destinations

Search for multiple Algolia ingestion destinations by their IDs using the US endpoint.

Search Dictionary Entries

Tool to search dictionary entries in Algolia dictionaries.

Search Facet Values

Tool to search for values of a specified facet attribute.

Search Algolia Index

Tool to perform a search on a specified Algolia index.

Search Multiple Indices

Tool to perform searches across multiple indices in a single call.

Search Recommend Rules

Search Recommend rules in a specified index and model.

Search Sources

Search for multiple Algolia Ingestion API sources by their IDs using the US ingestion endpoint.

Search Synonyms

Search synonyms in a specified Algolia index, optionally matching a query or filtering by synonym type.

Search Transformations

Tool to search for transformations by IDs in Algolia Ingestion API.

Set Dictionary Settings

Tool to update dictionary settings for Algolia.

Set Personalization Strategy

Tool to define personalization strategy that controls how user behavior affects search results.

Set Index Settings

Tool to update an Algolia index's settings.

Stop AB Test

Tool to stop an A/B test by its unique identifier.

Try Transformation

Tool to try a transformation before creating it in Algolia.

Try Transformation Before Update

Tool to test a transformation before updating it in Algolia Ingestion API.

Update API Key

Tool to update the permissions and settings of an existing API key.

Update Authentication

Update the name or credentials of an Algolia ingestion authentication resource in the US region.

Update Query Suggestions Config

Tool to update an existing Query Suggestions configuration.

Update Destination

Update an Algolia ingestion destination using the US endpoint, including its configuration, name, type or associated transformations.

Update Dictionary Entries

Batch add or delete entries in an Algolia stopwords, plurals, or compounds dictionary.

Update Record Partially

Tool to add or update attributes in a single record.

Update Source

Tool to update a source in the Algolia Ingestion API.

Update Task

Partially update an Algolia Ingestion API task using the US ingestion endpoint.

Update Transformation

Tool to update an existing transformation in Algolia Ingestion API.

Validate Source

Tool to validate a source payload before creating it in Algolia.

Validate Source Before Update

Tool to validate a source update payload in the Algolia Ingestion API.

FAQ

Frequently asked questions

Start with Algolia.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Algolia tool your agent needs.Free to start.

Start building