Integrating Zapier MCP into a Chat System

Source: Dev.to

Introduction

While working on a chat-based automation prototype, I got the opportunity to explore integrating a Zapier MCP server into a chat-based system. The goal was to allow users to trigger real‑world actions directly from chat without writing custom workflows for every use case.

This post explains how I approached the integration, the architecture I followed, how I designed the UI, and the problems I faced while working with Zapier MCP.

Understanding the architecture

Before writing any code, I focused on understanding the core components involved:

• Tools – actions such as sending emails, updating spreadsheets, or creating tasks.
• MCP server – a server that exposes tools in a standardized way (Zapier MCP in this case).
• MCP client – the LLM (Claude) that can discover and call available tools.
• MCP host – the application that connects user input, the LLM, and the MCP server.

Once these roles were clear, the overall system design became easier to reason about. MCP works as a bridge between LLMs and external tools, avoiding the need for manual integrations.

Overall flow

The flow I followed in the system was straightforward:

1. The user provides input.
2. The LLM discovers relevant tools.
3. The LLM maps the user intent to tool instructions.
4. Tools are executed via Zapier MCP.
5. The LLM formats the final response.

Summary:
User intent → tool discovery → tool execution → formatted response

Tool discovery and execution

In practice, the process looked like this:

1. Available tools and user input are sent to Claude.
2. Claude returns a list of relevant tools.
3. The discovered tools are sent back to Claude to map instructions.
4. Zapier MCP executes the instructions.
5. Claude formats the tool responses into a final output.

This approach required multiple LLM calls, which later became one of the main drawbacks.

Setting up Zapier MCP

Setting up Zapier MCP was relatively simple:

1. Create a Zapier account and select the needed tools.
2. Enable the Zapier MCP server.
3. Copy the MCP server URL and API key.
4. Connect this endpoint to Claude using the Anthropic Messages API.

Once connected, I could query the system to discover available tools, and Zapier MCP handled the execution layer reliably.

UI design

The UI was intentionally minimal. It consisted of:

• A chat input.
• A panel showing active tool execution states.
• A final section displaying completed results.

The goal was to make tool usage transparent so users could see what was running and when execution was complete, reducing the feeling of a black‑box system.

What worked well

• Zapier MCP was easy to integrate and suited quick experimentation.
• It removed the need to manually connect multiple APIs, allowing the LLM to focus on intent and orchestration.
• For fast iteration and prototyping, this setup was effective.
• I briefly tried n8n, but it felt heavier for quick experiments, so Zapier was a better fit for my workflow.

Limitations and frustrations

Multiple LLM calls

To produce a single clean response, the system required separate LLM calls for tool discovery, instruction mapping, and response formatting. Reducing these steps without adding extra glue code would improve the developer experience.

Closed‑source nature

Zapier is closed source, which limits visibility into internal execution. Debugging and customization beyond the exposed interface are restricted.

Limited control

The abstraction speeds development but sacrifices fine‑grained control over execution logic, which can be an issue for complex workflows.

Conclusion

Integrating Zapier MCP into a chat system was a solid experience overall. It works well for rapid development, experimentation, and proof‑of‑concept builds. However, for advanced workflows that require deep control and visibility, additional layers or alternative approaches may be needed.

This experiment helped me better understand how LLM‑driven tool orchestration can be built using MCP‑based systems.