Third-Party Tool Integrations via MCP

Overview

Beyond custom function tools that call your own webhook, Sulus assistants can connect directly to third-party MCP (Model Context Protocol) servers and use their tools during a live call. This lets an assistant reach thousands of pre-built app integrations — through providers like Zapier, Make.com, and Composio — without you writing and hosting a webhook for each one.

This is configured as a tool of type mcp, pointed at the provider's MCP server via a server.url field. It's a different setup from the Claude Desktop / IDE MCP connection covered in MCP Integration, which connects an AI coding assistant to Sulus's own platform APIs, not to third-party apps.

Not every system has a native MCP server. Popular CRMs — Salesforce, HubSpot, and Pipedrive — don't currently expose one, so those are connected using the Custom Tool / webhook pattern covered near the end of this page, and detailed further in Custom Function Tools.

Zapier's MCP server exposes access to its full library of connected apps and actions as callable tools.

1. Open Zapier's MCP server dashboard and generate an MCP server URL for your account. Treat this URL as a credential — anyone with it can authenticate to your Zapier MCP server.
2. In the Sulus Dashboard, go to Tools and click Create Tool.
3. Select MCP as the tool type.
4. Give it a name and a description explaining when the assistant should use it.
5. Paste your generated Zapier MCP URL into the serverUrl field.
6. Go to Assistants, select your assistant, open the Tools tab, choose this MCP tool from the dropdown, and click Publish.

Or configure it directly via the API:

{
  "model": {
    "provider": "openai",
    "model": "gpt-4o",
    "tools": [
      {
        "type": "mcp",
        "function": {
          "name": "mcpTools"
        },
        "server": {
          "url": "https://mcp.zapier.com/api/mcp/s/your-mcp-id/mcp"
        }
      }
    ]
  }
}

Zapier's MCP server gives access to thousands of connected apps and actions without you building a direct API integration for each one.

Make.com (formerly Integromat) lets you expose your own Make scenarios as MCP tools, so your assistant can trigger business logic and app integrations you've already built.

Step 1: Prepare your Make scenarios

• Define each scenario's inputs and outputs clearly.
• Set the scenario to be scheduled on demand so it can be triggered as a tool call rather than on a timer.

Step 2: Get your Make MCP token

1. In Make, go to your profile, then the API Access tab.
2. Click Tokens, then Add token.
3. Copy the generated MCP server URL/token. Treat it as a credential and keep it secure.

Step 3: Set Tool Access Control in Make to define which of your scenarios are exposed through this MCP URL.

Step 4: Create the MCP tool in Sulus

1. Go to Dashboard → Tools → Create Tool and select MCP.
2. Name it and describe when it should be invoked.
3. Set serverUrl to your Make MCP URL.
4. Add the tool to your assistant from Assistants → Tools and click Publish.

{
  "type": "mcp",
  "function": {
    "name": "mcpTools"
  },
  "server": {
    "url": "https://your-make-mcp-url/mcp",
    "headers": {
      "Authorization": "Bearer your-token"
    }
  }
}

Keep individual Make scenario outputs focused. Scenarios that return large amounts of data can overflow the assistant's context window mid-call.

Composio provides MCP servers for individual app integrations (Gmail, GitHub, and many others), each with its own connected-account authentication flow.

1. Log in to Composio's MCP dashboard.
2. Select the app you want to integrate (for example, Gmail).
3. Enable the MCP server for that app and complete the authentication flow to connect your account.
4. Create a server and copy the generated MCP URL.

Then, in Sulus:

1. Go to Dashboard → Tools → Create Tool and select MCP.
2. Name it and describe when the assistant should invoke it.
3. Set serverUrl to your Composio-generated URL.
4. Add the tool to your assistant from Assistants → Tools and click Publish.

{
  "type": "mcp",
  "server": {
    "url": "https://mcp.composio.dev/your-generated-url",
    "headers": {
      "Authorization": "Bearer your-token"
    }
  }
}

Composio integrations can return large payloads (for example, GitHub API queries). Configure focused, filtered responses where possible to avoid overflowing the assistant's context window.

At the start of a call, Sulus connects to the configured MCP server, fetches its current list of available tools, and dynamically adds them to the assistant for that call. Each time the assistant invokes one of those tools, Sulus opens a new connection to the MCP server and includes an X-Call-Id (or X-Chat-Id for chat) header so the provider can identify the session. Use the default Streamable HTTP protocol unless you have a specific reason to use SSE.

Salesforce, HubSpot, and Pipedrive don't currently expose an MCP server, so they're connected as Custom (function) Tools instead — your assistant calls a function, and your own webhook server translates that into a request against the CRM's REST API.

1. In Dashboard → Tools → Create Tool, select Function instead of MCP.
2. Define a function name (e.g. lookup_lead, update_crm), a description, and the parameters the assistant should pass (e.g. lead_id, call_outcome).
3. Set server.url to your own webhook endpoint — not the CRM's URL directly.

Your webhook receives a POST request containing a toolCallList, looks up the matching call, queries the CRM's own REST API, and returns a result:

app.post("/crm-webhook", async (req, res) => {
  const payload = req.body.message;

  for (const toolCall of payload.toolCallList) {
    if (toolCall.function?.name === "lookup_lead") {
      const { lead_id } = toolCall.function.arguments;
      const leadData = await fetchFromCRM(lead_id);

      return res.json({
        results: [
          {
            toolCallId: toolCall.id,
            result: JSON.stringify(leadData),
          },
        ],
      });
    }
  }
});

Each CRM has its own REST API your webhook calls behind the scenes (for example, Salesforce's REST API, HubSpot's API, or Pipedrive's API) — see each vendor's own developer documentation for endpoint details. For the full custom tool configuration reference, see Custom Function Tools.

• Treat every MCP server URL and CRM webhook secret as a credential — keep them out of source control and rotate them if exposed.
• Keep tool responses focused. Large payloads from either an MCP provider or a CRM webhook can overflow the assistant's context window and degrade call performance.
• Test any new MCP or custom tool with realistic queries before adding it to a production assistant.