Introduction

Since the inception of the Model Context Protocol (MCP), we've been envisioning and designing how it can be integrated into the SnapLogic platform. We've recently received a significant number of inquiries about MCP, and we're excited to share our progress, the features we'll be supporting, our release timeline, and how you can get started creating MCP servers and clients within SnapLogic. If you're interested, we encourage you to reach out!

Understanding the MCP Protocol

The MCP protocol allows tools, data resources, and prompts to be published by an MCP server in a way that Large Language Models (LLMs) can understand. This empowers LLMs to autonomously interact with these resources via an MCP client, expanding their capabilities to perform actions, retrieve information, and execute complex workflows.

MCP Protocol primarily supports:

• Tools: Functions an LLM can invoke (e.g., data lookups, operational tasks).
• Resources: File-like data an LLM can read (e.g., API responses, file contents).
• Prompts: Pre-written templates to guide LLM interaction with the server.
• Sampling (not widely used): Allows client-hosted LLMs to be used by remote MCP servers.

An MCP client can, therefore, request to list available tools, call specific tools, list resources, or read resource content from a server.

Transport and Authentication

MCP protocol offers flexible transport options, including STDIO or HTTP (SSE or Streamable-HTTP) for local deployments, and HTTP (SSE or Streamable-HTTP) for remote deployments.

While the protocol proposes OAuth 2.1 for authentication, an MCP server can also use custom headers for security.

Release Timeline

We're excited to bring MCP support to SnapLogic with two key releases:

August Release: MCP Client Support

We'll be releasing two new snaps: the MCP Function Generator Snap and the MCP Invoke Snap. These will be available in the AgentCreator Experimental (Beta) Snap Pack. With these Snaps, your SnapLogic agent can access the services and resources available on the public MCP server.

Late Q3 Release: MCP Server Support

Our initial MCP server support will focus on tool operations, including the ability to list tools and call tools. For authentication, it will support custom header-based authentication. Users will be able to leverage the MCP Server functionality by subscribing to this feature.

If you're eager to be among the first to test these new capabilities and provide feedback, please reach out to the Project Manager Team, at pm-team@snaplogic.com. We're looking forward to seeing what you build with SnapLogic MCP.

SnapLogic MCP Client

MCP Clients in SnapLogic enable users to connect to MCP servers as part of their Agent. An example can be connecting to the Firecrawl MCP server for a data scraping Agent, or other use cases that can leverage the created MCP servers.

The MCP Client support in SnapLogic consists of two Snaps, the MCP Function Generator Snap and the MCP Invoke Snap. From a high-level perspective, the MCP Function generator Snap allows users to list available tools from an MCP server, and the MCP Invoke Snap allows users to perform operations such as call tools, list resources, and read resources from an MCP server.

Let’s dive into the individual pieces.

MCP SSE Account

To connect to an MCP Server, we will need an account to specify the URI of the server to connect to.

MCP SSE Account

Properties

• URI
  • The URI of the server to connect to. Don’t need to include the /sse path
• Additional headers
  • Additional HTTP headers to be sent to the server
• Timeout
  • The timeout value in seconds, if the result is not returned within the timeout, the Snap will return an error.

MCP Function Generator Snap

MCP Function Generator Snap

The MCP Function Generator Snap enables users to retrieve the list of tools as SnapLogic function definitions to be used in a Tool Calling Snap.

Properties

• Account
  • An MCP SSE account is required to connect to an MCP Server.
• Expose Tools
  • List all available tools from an MCP server as SnapLogic function definitions
• Expose Resources
  • Add list_resources, read_resource as SnapLogic function definitions to allow LLMs to use resources/read and resources/list (MCP Resources).

Definitions for list resource and read resource

[ { "sl_type": "function", "name": "list_resources", "description": "This function lists all available resources on the MCP server. Return a list of resources with their URIs.", "strict": false, "sl_tool_metadata": { "operation": "resources/list" } }, { "sl_type": "function", "name": "read_resource", "description": "This function returns the content of the resource from the MCP server given the URI of the resource.", "strict": false, "sl_tool_metadata": { "operation": "resources/read" }, "parameters": [ { "name": "uri", "type": "STRING", "description": "Unique identifier for the resource", "required": true } ] } ]

MCP Invoke Snap

MCP Invoke Snap

The MCP Invoke Snap enables users to perform operations such as tools/call, resources/list, and resources/read to an MCP server.

Properties

• Account
  • An account is required to use the MCP Invoke Snap
• Operation
  • The operation to perform on the MCP server. The operation must be one of tools/call, resources/list, or resources/read
• Tool Name
  • The name of the tool to call. Only enabled and required when the operation is tools/call
• Parameters
  • The parameters to be added to the operation. Only enabled for resources/read and tools/call. Required for resources/read, and optional for tools/call, based on the tool.

MCP Agents in pipeline action

MCP Agent Driver pipeline

An MCP Agent Driver pipeline is like any other MCP Agent pipeline; we’ll need to provide the system prompt, user prompt, and run it with the PipeLoop Snap.

MCP Agent Worker pipeline

Here’s an example of an MCP Agent with a single MCP Server connection. The MCP Agent Worker is connected to one MCP Server.

MCP Client Snaps can be used together with AgentCreator Snaps, such as the Multi-Pipeline Function Generator and Pipeline Execute Snap, as SnapLogic Functions, tools. This allows users to use tools provided by MCP servers and internal tools, without sacrificing safety and freedom when building an Agent.

Agent Worker with MCP Client Snaps

 

SnapLogic MCP Server

In SnapLogic, an MCP Server allows you to expose SnapLogic pipelines as dynamic tools that can be discovered and invoked by language models or external systems.

By registering an MCP Server, you effectively provide a API that language models and other clients can use to perform operations such as data retrieval, transformation, enrichment, or automation, all orchestrated through SnapLogic pipelines.

For the initial phase, we'll support connections to the server via HTTP + SSE.

Core Capabilities

The MCP Server provides two core capabilities. 

The first is listing tools, which returns structured metadata that describes the available pipelines. This metadata includes the tool name, a description, the input schema in JSON Schema format, and any additional relevant information. This allows clients to dynamically discover which operations are available for invocation. 

The second capability is calling tools, where a specific pipeline is executed as a tool using structured input parameters, and the output is returned. 

Both of these operations—tool listing and tool calling—are exposed through standard JSON-RPC methods, specifically tools/list and tools/call, accessible over HTTP.

Prerequisite

You'll need to prepare your tool pipelines in advance. During the server creation process, these can be added and exposed as tools for external LLMs to use.

MCP Server Pipeline Components

A typical MCP server pipeline consists of four Snaps, each with a dedicated role:

1. Router

• What it does: Routes incoming JSON requests—which differ from direct JSON-RPC requests sent by an MCP client—to either the list tools branch or the call tool branch.
• How: Examines the request payload (typically the method field) to determine which action to perform.
  
  2. Multi-Pipeline Function Generator (Listing Tools) 

• What it does: Converts a list of pipeline references into tool metadata. This is where you define the pipelines you want the server to expose as tools.
• Output: For each pipeline, generates:
  • Tool name
  • Description
  • Parameters (as JSON Schema)
  • Other metadata
• Purpose: Allows clients (e.g., an LLM) to query what tools are available without prior knowledge.

3. Pipeline Execute (Calling Tools)

• What it does: Dynamically invokes the selected SnapLogic pipeline and returns structured outputs.
• How: Accepts parameters encoded in the request body, maps them to the pipeline’s expected inputs, and executes the pipeline.
• Purpose: Provides flexible runtime execution of tools based on user or model requests.

4. Union

• What it does: Merges the result streams from both branches (list and call) into a single output stream for consistent response formatting.

Request Flows

Below are example flows showing how requests are processed:

🟢 tools/list

1. Client sends a JSON-RPC request with method = "tools/list".
2. Router directs the request to the Multi-Pipeline Function Generator.
3. Tool metadata is generated and returned in the response.
4. Union Snap merges and outputs the content.

✅ Result: The client receives a JSON list describing all available tools.

�� tools/call

1. Client sends a JSON-RPC request with method = "tools/call" and the tool name + parameters.
2. Router sends this to the Pipeline Execute Snap.
3. The selected pipeline is invoked with the given parameters.
4. Output is collected and merged via Union.

✅ Result: The client gets the execution result of the selected tool.

Registering an MCP Server

Once your MCP server pipeline is created:

1. Create a Trigger Task and Register as an MCP Server
   
   1. Navigate to the Designer > Create Trigger Task
   2. Choose a Groundplex.
      (Note: This capability currently requires a Groundplex, not a Cloudplex.)
   3. Select your MCP pipeline.
   4. Click Register as MCP server
   5. Configure node and authentication. 
      
      
2. Find your MCP Server URL
   
   1. Navigate to the Manager > Tasks
   2. The Task Details page exposes a unique HTTP endpoint.
   3. This endpoint is treated as your MCP Server URL.

After registration, clients such as AI models or orchestration engines can interact with the MCP Server by calling the /tools/list endpoint to discover the available tools, and the /tools/call endpoint to invoke a specific tool using a structured JSON payload.

Connect to a SnapLogic MCP Server from a Client

After the MCP server is successfully published, using the SnapLogic MCP server is no different from using other MCP servers running in SSE mode. It can be connected to by any MCP client that supports SSE mode; all you need is the MCP Server URL (and the Bearer Token if authentication is enabled during server registration).

Configuration

First, you need to add your MCP server in the settings of the MCP client. Taking Claude Desktop as an example, you'll need to modify your Claude Desktop configuration file. The configuration file is typically located at:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add your remote MCP server configuration to the mcpServers section:

{ "mcpServers": { "SL_MCP_server": { "command": "npx", "args": [ "mcp-remote", "http://devhost9000.example.com:9000/mcp/6873ff343a91cab6b00014a5/sse", "--header", "Authorization: Bearer your_token_here" ] } } }

Key Components

• Server Name: SL_MCP_server - A unique identifier for your MCP server
• Command: npx - Uses the Node.js package runner to execute the mcp-remote package
• URL: The SSE endpoint URL of your remote MCP server (note the /sse suffix)
• Authentication: Use the --header flag to include authorization tokens if the server enabled authentication

Requirements

Ensure you have Node.js installed on your system, as the configuration uses npx to run the mcp-remote package. Replace the example URL and authorization token with your actual server details before saving the configuration.

After updating the configuration file, restart Claude Desktop for the changes to take effect.

To conclude, the MCP Server in SnapLogic is a framework that allows you to expose pipelines as dynamic tools accessible through a single HTTP endpoint. This capability is designed for integration with language models and external systems that need to discover and invoke SnapLogic workflows at runtime. MCP Servers make it possible to build flexible, composable APIs that return structured results, supporting use cases such as conversational AI, automated data orchestration, and intelligent application workflows.

Conclusion

SnapLogic's integration of the MCP protocol marks a significant leap forward in empowering LLMs to dynamically discover and invoke SnapLogic pipelines as sophisticated tools, transforming how you build conversational AI, automate complex data orchestrations, and create truly intelligent applications. We're excited to see the innovative solutions you'll develop with these powerful new capabilities.