Mcp

What is Mcp about?

Mcp provides experimental Model Context Protocol (MCP) servers that act as a bridge between Claude Desktop (or other MCP‑compatible tools) and Algolia's search, analytics, and recommendation APIs. It lets users run a local Go binary to expose Algolia functionality as AI‑accessible tools.

How to use Mcp?

1. Install Go (https://go.dev/doc/install).
2. Clone the repository and build the server:

   git clone git@github.com:algolia/mcp.git
   cd mcp/cmd/mcp
   go build
   

3. Add the built binary to your MCP server configuration (e.g., in Claude Desktop settings) using the path to the mcp executable and the required environment variables.
4. Restart the client tool; the algolia tool will appear and can be invoked via natural‑language prompts.
5. Optional: run the MCP inspector with npx @modelcontextprotocol/inspector ./mcp to test tools manually.

Key features of Mcp

• Supports a wide range of Algolia tools: search, collections, analytics, AB testing, query suggestions, recommendations, monitoring, usage, etc.
• Fine‑grained tool activation via MCP_ENABLED_TOOLS (comma‑separated list).
• Two server modes: standard stdio (default) and Server‑Sent Events (MCP_SERVER_TYPE="sse").
• Write capabilities guarded by ALGOLIA_WRITE_API_KEY (admin key).
• Simple environment‑variable configuration makes it easy to switch accounts or indexes.

Use cases of Mcp

• Interactive product search: ask an AI model to fetch items matching custom filters (e.g., brand = "Nike" and price < 100).
• Content management: add, update, or delete documents in an Algolia index via natural language.
• Index tuning: modify searchable attributes, ranking rules, or other settings on the fly.
• Analytics queries: retrieve usage stats or monitoring data without writing custom API calls.
• Local development & debugging: run the inspector to explore tool behavior before integration.

FAQ from Mcp

Q: Is this server production‑ready? A: The repository is experimental and not covered by Algolia's SLA. Use it for exploration, prototypes, or local development only.

Q: Do I need a Node.js version of the server? A: A Go implementation is provided here; a separate Node.js server exists at https://github.com/algolia/mcp-node.

Q: How do I enable only specific tools? A: Set the MCP_ENABLED_TOOLS environment variable to a comma‑separated list of tool names (e.g., search,collections). Leaving it empty enables all tools.

Q: Can I run Mcp with Ollama? A: Yes. Use mcphost (https://github.com/mark3labs/mcphost) with a JSON config that points to the built binary, then launch it with an Ollama model.

Q: Where can I learn more? A: See the Algolia blog post https://www.algolia.com/blog/engineering/algolia-mcp-server and the official MCP documentation at https://modelcontextprotocol.io.

MCP

This repository contains experimental Model Context Protocol (or MCP) servers for interacting with Algolia APIs. This MCP repo is something we're sharing for you to explore and experiment with. Feel free to use it, fork it, or build on top of it — but just know that it's not officially supported by Algolia and isn't covered under our SLA. We might update it, break it, or remove it entirely at any time. If you customize or configure things here, there's a chance that work could be lost. Also, using MCP in production could affect your Algolia usage.

We also have a Node.js MCP Server that you can find here: https://github.com/algolia/mcp-node.

If you have feedback or ideas (even code!), we'd love to hear it. Just know that we might use it to help improve our products. This project is provided "as is" and "as available," with no guarantees or warranties. To be super clear: MCP isn't considered an "API Client" for SLA purposes.

Installation

First follow the quick start, which will install Claude Desktop and setup a sample Fileserver MCP server. This is a great introduction to using MCP and will let you debug things using the official guide if there are issues.

Setup the prototype Algolia MCP server

Requirements:

• Go (https://go.dev/doc/install)

Clone the repo and build the server

Clone the repo, amd build the mcp server:

$ git clone git@github.com:algolia/mcp.git
$ cd mcp/cmd/mcp
$ go build

We need to have the full path of the built server binary:

$ pwd
/path/to/the/repo/cmd/mcp

NOTE: When adding this command to your configuration, you must specify the binary along with the path (/path/to/the/repo/cmd/mcp/mcp)

Update the settings to point to the new server

In Claude desktop edit the settings as per https://modelcontextprotocol.io/quickstart/user#2-add-the-filesystem-mcp-server and this time add the server definition for algolia (using the server path that you found earlier).

{
   "mcpServers": {
      "algolia": {
         "command": "/path/to/the/repo/cmd/mcp/mcp",
         "env": {
            "ALGOLIA_APP_ID": "<APP_ID>",
            "ALGOLIA_INDEX_NAME": "<INDEX_NAME>",
            "ALGOLIA_API_KEY": "<API_KEY>",
            "ALGOLIA_WRITE_API_KEY": "<ADMIN_API_KEY>",  /* if you want to allow write operations, use your ADMIN key here */
            "MCP_ENABLED_TOOLS": "",  /* optional: specify which tools to enable (e.g., "search,collections") */
            "MCP_SERVER_TYPE": "stdio",  /* optional: server type, either "stdio" (default) or "sse". If not set, defaults to "stdio" */
            "MCP_SSE_PORT": "8080"  /* optional: port for SSE server, default is 8080 (only used when MCP_SERVER_TYPE is "sse") */
         }
      }
   }
}

By default, all available tools are enabled when MCP_ENABLED_TOOLS is empty or not set. If you want to enable only specific tools, you can set this variable to a comma-separated list of tool names. Available tools are: abtesting, analytics, collections, monitoring, querysuggestions, recommend, search, search_read, search_write, usage.

• search: Enables all search operations (both read and write)
• search_read: Enables only read operations (list indices, get settings, run queries, get objects)
• search_write: Enables only write operations (clear, copy, delete, move, set settings, delete objects, insert objects)

Restart Claude desktop, and you should see a new "algolia" tool is available.

Debugging

You can run the Inspector (see https://modelcontextprotocol.io/docs/tools/inspector) to check the MCP features and run them manually.

From the repo root, setup the environment

$ export ALGOLIA_APP_ID=""
$ export ALGOLIA_INDEX_NAME=""
$ export ALGOLIA_API_KEY=""
$ export ALGOLIA_WRITE_API_KEY=""  # if you want to allow write operations, use your ADMIN key here
$ export MCP_ENABLED_TOOLS=""  # if you want to restrict the tools activated you can optionally specify a list
$ export MCP_SERVER_TYPE="stdio"  # optional: server type, either "stdio" (default) or "sse". If not set, defaults to "stdio"
$ export MCP_SSE_PORT="8080"  # optional: port for SSE server, default is 8080 (only used when MCP_SERVER_TYPE is "sse")

Move into the server directory, and rebuild (if necessary):

$ cd cmd/mcp
$ go build # might already be up-to-date

Run the MCP inspector on the server:

$ npx @modelcontextprotocol/inspector ./mcp

Using with Ollama

You can actually run a local mcphost (which orchestrates the MCP servers for you), and then use them with other models locally via Ollama.

We are using https://github.com/mark3labs/mcphost for this.

As per the README you need a a config file, so you can copy the Claude one, and put it somewhere sensible so you can use it on the command line (for example ~/mcp.json)

{
   "mcpServers": {
      "algolia": {
         "command": "/path/to/the/repo/cmd/mcp/mcp",
         "env": {
            "ALGOLIA_APP_ID": "<APP_ID>",
            "ALGOLIA_INDEX_NAME": "<INDEX_NAME>",
            "ALGOLIA_API_KEY": "<API_KEY>",
            "MCP_ENABLED_TOOLS": "",  /* optional: specify which tools to enable (e.g., "search,collections") */
            "MCP_SERVER_TYPE": "stdio",  /* optional: server type, either "stdio" (default) or "sse". If not set, defaults to "stdio" */
            "MCP_SSE_PORT": "8080"  /* optional: port for SSE server, default is 8080 (only used when MCP_SERVER_TYPE is "sse") */
         }
      }
   }
}

By default, all available tools are enabled when MCP_ENABLED_TOOLS is empty or not set. If you want to enable only specific tools, you can set this variable to a comma-separated list of tool names. Available tools are: abtesting, analytics, collections, monitoring, querysuggestions, recommend, search, search_read, search_write, usage. You can now run it directly (no need to check out the repo):

$ go run github.com/mark3labs/mcphost@latest --config ~/mcp.json -m ollama:qwen2.5:3b

FAQ

What sort of things can I do once I install this MCP?

Here are some sample prompts to seed your imagination:

• “Search all products in the index where brand = ‘Nike’ and price < 100.”
• “Add this JSON object to the blog_posts index.”
• “Update the searchable attributes for the recipes index to include ingredients.”
• “Configure my index to rank nebula_award winners higher”

Where can I read more about the Algolia MCP server?

Check out this blog post including an embedded demo video.

Resource templates and root are not supported by Claude desktop right now

This is a weird one, since there is a bunch of content online showing the templates, maybe it's just not GA yet.