MCP Server Node

Connect to an external MCP server and invoke a tool. Use template variables like {{.variable}} in arguments to reference values from previous steps.

Overview

The MCP Server node connects to a remote Model Context Protocol server, fetches its available tools, and lets you invoke one within your workflow. This is how you integrate external services — Stripe, GitHub, databases, or any MCP-compatible server — directly into your flows without writing custom HTTP requests.

Configuration

Connection

Field	Description	Required
`Transport Type`	How to connect to the server	Yes
`Server URL`	The MCP server endpoint	Yes
`Auth Type`	Authentication method	Yes
`Output Variable`	Variable name for the tool result	Yes

Transport Types

Type	Description
`SSE`	Server-Sent Events — persistent connection with real-time streaming
`Streamable HTTP`	Standard HTTP with streaming support

Auth Types

Type	Fields	Description
`None`	—	No authentication required
`API Key`	Header Name, API Key	Sends the key in a custom header (e.g. `X-API-Key`)
`Bearer Token`	Bearer Token	Sends a `Bearer` token in the Authorization header

Tool Configuration

After connecting, the node fetches all available tools from the server. You then configure:

Field	Description	Required
`Select a tool`	Pick from the tools exposed by the server	Yes
`Timeout (seconds)`	Max time to wait for the tool response	No (default: 30)
`Tool Arguments`	Dynamic fields based on the selected tool's schema	Varies

Tool arguments are generated automatically from the server's tool definitions. Each argument shows its name, description, type, and whether it's required.

How It Works

Configure the connection (transport, URL, auth).
Click Connect & Fetch Tools to discover available tools.
Select a tool from the dropdown.
Fill in the tool arguments — use {{.variable}} syntax to inject values from previous nodes.
The result is stored in the output variable for downstream nodes.

Example: Search Stripe Documentation

Flow Start → MCP Server (Stripe)
                Tool: search_stripe_documentation
                Args: question = "How to create a subscription"
             → Model (summarize result)
             → Simple Output

Example: Create a Product via MCP

HTTP Request (get product data) → MCP Server (Stripe)
                                      Tool: create_product
                                      Args: name = {{.httpRequest.name}}
                                            description = {{.httpRequest.description}}
                                  → Simple Output

Example: Chain Multiple MCP Calls

MCP Server (fetch customers) → For Loop (each customer)
                                  → MCP Server (create invoice)
                                  → Delay (1 second)

Best Practices

Use SSE transport when the server supports it — it's more efficient for long-running tool calls
Store sensitive credentials (API keys, tokens) in the Vault and reference them with template variables
Set appropriate timeouts based on the tool's expected response time
Use the output variable name to clearly identify what data the tool returns (e.g. stripeCustomers, githubIssues)
Test tools individually with the Test Tool button before wiring them into complex flows