Expensivefav MCP

by expensivefav

299 downloads

Not rated

GitHub

Other

About

MCP is an experimental Model Context Protocol server that allows AI assistants to interact with Algolia APIs. It is intended for developers who want to query, add, update, or configure Algolia indices through natural language or an MCP-enabled client.

Details

Author: expensivefav
Downloads: 299
Categories: Other

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Expensivefav MCP

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

From the repository

Install Go, clone the repository, build the server binary, then add a server definition to Claude Desktop's settings. Configure the environment variables ALGOLIA_APP_ID, ALGOLIA_INDEX_NAME, ALGOLIA_API_KEY, and optionally ALGOLIA_WRITE_API_KEY (the admin key) for write operations. Restart Claude Desktop to access the "algolia" tool.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "expensivefav mcp": {
            "mcp-expensivefav": {
                "command": "npx",
                "args": [
                    "@modelcontextprotocol/inspector",
                    "./mcp"
                ]
            }
        }
    }
}

McpServers

{
    "mcp-expensivefav": {
        "command": "npx",
        "args": [
            "@modelcontextprotocol/inspector",
            "./mcp"
        ]
    }
}

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.

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 */
         }
      }
   }
}

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

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)

``json filename="~/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>" } } } }

You can now run it directly (no need to check out the repo):

shell

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

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

MCP

Installation

Setup the prototype Algolia MCP server

Clone the repo and build the server

Update the settings to point to the new server

Debugging

Using with Ollama

Install

More like this

Sequential Thinking

Filesystem

EverArt

Google Drive

Reactive Resume

FastMCP v2 🚀