Listen to this blog as a podcast:

Estimated time to read: 3 minutes

At this year’s DevCon, my talk was titled “Building an AI-powered MCP client for Algolia”, and in this summary post, I’ll walk you through the story behind it: what I built, why I built it, and how it all came together. You can also watch and follow along with the recorded presentation below:

The idea: Making Algolia conversational

It all started with a hackathon hosted by the Dev Community. I’d been exploring the Model Context Protocol (MCP) — a fascinating open framework that connects LLMs (Large Language Models) to external data tools like Slack, GitHub, Algolia, etc.

That’s when it hit me: What if I could turn Algolia into something I could just talk to?

Imagine skipping the dashboard clicks and instead asking,

“Show me all search operations on our production site from last week.”

That’s the problem I set out to solve — and what became my custom MCP client for Algolia.

How it works: The architecture behind the chat

At a high level, the system works like this:

• Frontend: Built with React, Vite, and Tailwind CSS. It provides a sleek, chat-style interface where users can type queries or choose predefined templates like “List all my apps” or “Show index configuration.”

• Backend: A FastAPI server in Python that connects the frontend to the AI model (I used Claude) and the Algolia MCP server.

• LLM: Processes user prompts, determines if a tool call is needed, and interacts with the MCP server to fetch or analyze data.

• MCP Server (Algolia): Bridges the LLM to Algolia’s APIs, enabling data retrieval, analysis, and visualization through natural language.

When a user asks a question, the flow looks like this:

Frontend → Backend → LLM → Algolia MCP Server → Data → LLM Response → Frontend Display

The result? You can literally chat with your Algolia instance.

Building the custom MCP client

Why build a custom client instead of just using an existing one? Flexibility.

A custom MCP client means:

• I can integrate it into any project I’m working on.

• I have complete control over the UI and behavior.

• I can extend it easily — adding themes, templates, or new tools.

• It’s cost-effective since I’m not bound by third-party limits.

I used a carefully crafted system prompt to tell the LLM how to structure responses — when to use markdown, how to render charts, and how to handle code blocks. This made the frontend rendering clean and intuitive.

Seeing it in action

During the live demo at DevCon, I showed how my MCP client could:

• Fetch and visualize the total number of search operations within a custom date range.

• Display detailed index configurations.

• Provide real-time incident reports for Algolia services.

• Generate charts and graphs directly in the chat interface.

It even supports themes — light, dark, and a custom “Algolia theme” inspired by the official Algolia website. Every chat is stored locally, so you can revisit previous queries anytime.

Lessons learned

Working on this project taught me a lot about how LLMs can integrate with developer tools in a meaningful way. The key takeaways:

• MCP isn’t just a connector — it’s a bridge that makes LLMs useful in production contexts.

• Algolia’s open MCP server made it surprisingly easy to experiment and extend functionality.

• Small details like good system prompts and UI polish make a huge difference in usability.

What’s next

I’ve made both the frontend and backend code public on GitHub — feel free to clone, fork, or break it however you like! 

If you’re interested in trying something similar, start by exploring the Algolia MCP server repository — it’s open source and well-documented. From there, experiment with connecting your own data tools to an LLM via MCP.

Thanks again to everyone who joined my session at Algolia DevCon. Turning Algolia into a conversational AI was one of the most fun projects I’ve ever built — and it’s just the beginning of what’s possible with MCP.