MCP N8n Server 5d3819d1

MCP开发工具

提供方 trieder83

开发工具 stdio · 本地进程 API Key 社区 / 第三方 Claude DesktopClaude
查看接入方式

一个将n8n自动化工作流作为MCP工具暴露的协议服务器,支持与AI助手和其他MCP客户端集成。

一句话选型结论

按资料字段整理

MCP N8n Server 5d3819d1 属于开发工具类 MCP 服务器,stdio · 本地进程,API Key,可直接接入 Claude Desktop、Claude,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式stdio · 本地进程 鉴权API Key 部署方式本地部署
GitHub 星标 0 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

开发工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

Shell混合部署工作流自动化AI集成HTTP服务Docker部署Kubernetes集成

安装与配置

stdio · 本地进程 API Key
客户端在本机拉起子进程,数据不出本机
docker run -d -p 8000:8000 \

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Docker,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在开发工具场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
MCP N8n Server 5d3819d1当前 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方trieder83上游标注的维护方 trieder83
分类开发工具本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Docker本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

20.2 KB
来自项目仓库与上游目录的原文,未做删改

MCP Server for n8n Workflow Integration

This project provides a Model Context Protocol (MCP) server that exposes n8n workflows as MCP tools using Streamable HTTP (Server-Sent Events). It allows you to integrate n8n automation workflows with AI assistants and other MCP clients.

!! use goose_1.12.0_amd64.deb since goose_1.12.1_amd64.deb is broken

Features

  • Expose n8n webhooks as MCP tools
  • Support for multiple workflows with custom input schemas
  • Authentication support (Basic Auth and Custom Headers)
  • Docker containerization
  • Kubernetes deployment with NodePort service
  • Configurable via environment variables or configuration files
  • SSE (Server-Sent Events) transport for MCP communication
  • Compatible with Codename Goose, Claude Desktop, and other MCP clients

Table of Contents

  • Architecture
  • Quick Start with Codename Goose
  • Configuration
  • HTTP Configuration
  • Running Locally
  • Docker Deployment
  • Kubernetes Deployment
  • Testing
  • Configuring MCP Clients
  • Workflow Authentication
  • Monitoring
  • Troubleshooting
  • Development

Architecture```

┌─────────────┐ ┌──────────────┐ ┌─────────┐
│ MCP Client │ ◄─HTTP─►│ MCP Server │ ◄─HTTP─► │ n8n │
│ (AI Model) │ │ (Python) │ │ │
│ Goose │ │ Port 8000 │ │Webhooks │
└─────────────┘ └──────────────┘ └─────────┘
│ │ │
│ POST /mcp │ POST /webhook/{id} │
│ (JSON-RPC 2.0) │ │
└───────────────────────┘ │
Streamable HTTP │
│
HTTP POST ──────────────┘


## Quick Start with Codename Goose

The fastest way to get started with Codename Goose:

1. **Start the MCP server**:```bash
docker run -d -p 8000:8000 \
  -e N8N_BASE_URL=http://your-n8n-host:31678 \
  -v $(pwd)/workflows.json:/app/workflows.json:ro \
  trieder83/mcp-n8n-server:latest
  1. Configure Goose (~/.config/goose/config.yaml):```bash

Edit Goose configuration

goose configure

Or manually add to ~/.config/goose/config.yaml:

Add this under 'extensions:' section:

``````yaml
extensions:
mcp-n8n-server:
available_tools: []
bundled: null
description: n8n workflow integration via MCP
enabled: true
env_keys: []
envs: {}
headers: {}
name: mcp-n8n-server
timeout: 300
type: streamable_http
uri: http://localhost:8000/mcp


3. **Start using workflows in Goose**:```bash
goose
# Inside Goose:
# "Run the chat_workflow with message 'Hello n8n!'"

See the Configuring MCP Clients section for detailed setup instructions.

Configuration

Workflow Configuration

Workflows are configured via a JSON file (workflows.json) or environment variable. Each workflow can specify:

  • name: Unique identifier for the MCP tool
  • webhook_id: n8n webhook ID (from webhook URL)
  • description: Description of the workflow
  • input_schema: JSON Schema for input parameters
  • required_fields: List of required input fields
  • auth_type: Authentication type ("basic", "header", or "none")
  • basic_auth: Base64-encoded credentials for Basic Auth
  • auth_header_name: Custom header name for authentication
  • auth_header_value: Custom header value for authentication
  • custom_headers: Additional custom headers (key-value pairs)

Example Workflow Configuration```json

[
{
"name": "chat_workflow",
"webhook_id": "919df572-8dcd-4cd6-b592-9e90ba0db414",
"description": "Process chat input through n8n workflow",
"input_schema": {
"chatInput": {
"type": "string",
"description": "The chat message to process"
}
},
"required_fields": ["chatInput"]
},
{
"name": "secure_workflow",
"webhook_id": "secure-webhook-id",
"description": "Workflow with Basic authentication",
"auth_type": "basic",
"basic_auth": "dXNlcm5hbWU6cGFzc3dvcmQ=",
"input_schema": {
"message": {
"type": "string",
"description": "Message to send"
}
},
"required_fields": ["message"]
}
]


### Environment Variables

| Variable | Description | Default |
|----------|-------------|---------|
| `SERVER_HOST` | Server bind address | `0.0.0.0` |
| `SERVER_PORT` | Server port | `8000` |
| `N8N_BASE_URL` | n8n instance base URL | `http://localhost:31678` |
| `N8N_WORKFLOWS_CONFIG` | Path to workflows JSON file | `workflows.json` |
| `N8N_WORKFLOWS_JSON` | Workflows JSON as string (alternative to file) | - |
| `N8N_AUTH_TYPE` | Global auth type (basic/header/none) | `none` |
| `N8N_BASIC_AUTH` | Global Basic Auth (base64) | - |
| `N8N_AUTH_HEADER_NAME` | Global auth header name | `Authorization` |
| `N8N_AUTH_HEADER_VALUE` | Global auth header value | - |

## HTTP Configuration

This MCP server uses **Streamable HTTP** as the transport protocol for MCP communication. It implements the MCP protocol over standard HTTP POST requests using JSON-RPC 2.0.

### Transport Type

- **Transport**: `http` (Streamable HTTP)
- **Protocol**: HTTP/HTTPS
- **Type**: JSON-RPC 2.0 over HTTP POST
- **Format**: Request-response pattern

### HTTP Endpoints

The server exposes the following HTTP endpoints:

| Endpoint | Method | Purpose | Description |
|----------|--------|---------|-------------|
| `/mcp` | POST | MCP Protocol | Main endpoint for MCP JSON-RPC 2.0 messages |
| `/` | GET | Health Check | Returns server health status with workflow count |
| `/health` | GET | Health Check | Same as `/` - returns detailed health information |
| `/ready` | GET | Readiness Check | Returns 200 if workflows loaded, 503 otherwise |

### Server Configuration```bash
# Default configuration
SERVER_HOST=0.0.0.0  # Bind to all interfaces
SERVER_PORT=8000     # HTTP port

# The server runs on plain HTTP (not HTTPS) by default
# Access via: http://localhost:8000

HTTP Transport Protocol

The MCP server implements streamable HTTP transport using JSON-RPC 2.0:```
Client Server
│ │
│ POST /mcp (initialize) │
├──────────────────────────────>│
│ <── JSON Response ───────────│
│ │
│ POST /mcp (tools/list) │
├──────────────────────────────>│
│ <── JSON Response ───────────│
│ │
│ POST /mcp (tools/call) │
├──────────────────────────────>│
│ <── JSON Response ───────────│
│ │


**How it works:**

1. **Initialize**: Client sends `initialize` method to `/mcp` endpoint
2. **List Tools**: Client sends `tools/list` to get available workflows
3. **Call Tool**: Client sends `tools/call` to execute a workflow
4. **Response**: Server responds synchronously with JSON-RPC result

**Supported MCP Methods:**
- `initialize` - Initialize the MCP connection
- `tools/list` - List all available n8n workflows
- `tools/call` - Execute a specific workflow

**Example MCP Client Configuration:**```json
{
  &quot;url&quot;: &quot;http://localhost:8000/mcp&quot;,
  &quot;transport&quot;: &quot;http&quot;,
  &quot;description&quot;: &quot;n8n MCP server with HTTP transport&quot;
}

Verification:```bash

Test initialization

curl -X POST http://localhost:8000/mcp \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}'

List tools

curl -X POST http://localhost:8000/mcp \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

Call a tool

curl -X POST http://localhost:8000/mcp \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"chat_workflow","arguments":{"chatInput":"test"}}}'


### Port Exposure

**Local Development:**
- Server runs on `http://0.0.0.0:8000`
- Accessible via `http://localhost:8000`

**Docker:**
- Container port: `8000`
- Host mapping: `-p 8000:8000`
- Access via: `http://localhost:8000`

**Kubernetes:**
- Service port: `8000`
- NodePort: `30888` (configured in `k8s/service.yaml`)
- Access via: `http://:30888`

### Adding HTTPS Support

For production deployments with HTTPS:

**Option 1: Use a Reverse Proxy (Recommended)**```nginx
# Nginx example
server {
    listen 443 ssl;
    server_name mcp.example.com;

    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;

    location / {
        proxy_pass http://localhost:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection &quot;upgrade&quot;;
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Option 2: Kubernetes Ingress with TLS```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: n8n-mcp-server
annotations:
cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
ingressClassName: nginx
tls:
- hosts:
- mcp.example.com
secretName: mcp-tls
rules:
- host: mcp.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: n8n-mcp-server
port:
number: 8000


### Health Checks

The server provides dedicated health check endpoints:```bash
# Basic health check
curl http://localhost:8000/health

# Expected response
{
  &quot;status&quot;: &quot;healthy&quot;,
  &quot;service&quot;: &quot;n8n-mcp-server&quot;,
  &quot;workflows_loaded&quot;: 4,
  &quot;n8n_base_url&quot;: &quot;http://localhost:31678&quot;
}

# Readiness check (returns 503 if no workflows loaded)
curl http://localhost:8000/ready

# Expected response when ready
{
  &quot;status&quot;: &quot;ready&quot;
}

Kubernetes Probes:
- Liveness Probe: GET /health - Checks if the server is running
- Readiness Probe: GET /ready - Checks if workflows are loaded and server is ready to accept requests

Running Locally

Prerequisites

  • Python 3.11+
  • n8n instance with webhooks enabled

Setup

  1. Clone the repository:```bash
    git clone <repository-url>
    cd mcp-n8n-server

2. Install dependencies:```bash
pip install -r requirements.txt
  1. Configure your workflows in workflows.json

  2. Set environment variables (optional):```bash
    cp .env.example .env

Edit .env with your configuration


5. Run the server:```bash
python server.py

The server will be available at http://localhost:8000

Docker Deployment

Build the Docker Image```bash

docker build --network=host -t trieder83/mcp-n8n-server:latest .

Or use make

make docker-build


### Push to Docker Hub```bash
docker push trieder83/mcp-n8n-server:latest
# Or use make
make docker-push

Run the Container```bash

docker run -d \
--name n8n-mcp-server \
-p 8000:8000 \
-e N8N_BASE_URL=http://your-n8n-instance:31678 \
-v $(pwd)/workflows.json:/app/workflows.json:ro \
trieder83/mcp-n8n-server:latest

Or use make

make docker-run


## Kubernetes Deployment

### Prerequisites

- Kubernetes cluster (v1.20+)
- kubectl configured

### Deploy to Kubernetes

1. Update the ConfigMap in `k8s/deployment.yaml` with your workflows

2. Update the n8n base URL:```yaml
# In k8s/deployment.yaml, update:
- name: N8N_BASE_URL
  value: &quot;http://your-n8n-service:31678&quot;
  1. (Optional) Configure authentication secrets:```bash

Create Basic Auth secret

echo -n "username:password" | base64
kubectl create secret generic n8n-mcp-secrets \
--from-literal=basic-auth='<base64-encoded-credentials>'

Or create header auth secret

kubectl create secret generic n8n-mcp-secrets \
--from-literal=auth-token='your-api-key'


4. Deploy:```bash
kubectl apply -f k8s/deployment.yaml
kubectl apply -f k8s/service.yaml
  1. Check the deployment:```bash
    kubectl get pods -l app=n8n-mcp-server
    kubectl get svc n8n-mcp-server

The service will be exposed on NodePort 30800. Access it via:```
http://&lt;node-ip&gt;:30800

Accessing the Service```bash

Get node IP

kubectl get nodes -o wide

Access the service

curl http://<node-ip>:30800/


## Testing

### Test n8n Webhook Directly```bash
curl -X POST \
  -H &quot;Content-Type: application/json&quot; \
  http://localhost:31678/webhook/919df572-8dcd-4cd6-b592-9e90ba0db414 \
  -d &#x27;{&quot;chatInput&quot;:&quot;test&quot;}&#x27;

Test MCP Server

The MCP server uses SSE transport. Connect using an MCP client or test with curl:```bash

List available tools

curl http://localhost:8000/messages


## Configuring MCP Clients

### Codename Goose Configuration

To use this n8n MCP server with Codename Goose, you need to configure it in Goose&#x27;s MCP settings.

#### 1. Local Development Setup

Edit your Goose configuration file at `~/.config/goose/config.yaml`:```yaml
extensions:
  mcp-n8n-server:
    available_tools: []
    bundled: null
    description: n8n workflow integration via MCP
    enabled: true
    env_keys: []
    envs: {}
    headers: {}
    name: mcp-n8n-server
    timeout: 300
    type: streamable_http
    uri: http://localhost:8000/mcp

2. Kubernetes/Remote Setup

If your MCP server is running in Kubernetes with NodePort:```yaml
extensions:
mcp-n8n-server:
available_tools: []
bundled: null
description: n8n workflow integration via Kubernetes
enabled: true
env_keys: []
envs: {}
headers: {}
name: mcp-n8n-server
timeout: 300
type: streamable_http
uri: http://<kubernetes-node-ip>:30888/mcp


#### 3. Using Docker Compose (Recommended for local development)

Create a `docker-compose.yml` file to run both Goose and the MCP server together:```yaml
version: &#x27;3.8&#x27;

services:
  mcp-server:
    image: trieder83/mcp-n8n-server:latest
    container_name: n8n-mcp-server
    ports:
      - &quot;8000:8000&quot;
    environment:
      - N8N_BASE_URL=http://your-n8n-instance:31678
      - N8N_WORKFLOWS_CONFIG=/config/workflows.json
    volumes:
      - ./workflows.json:/config/workflows.json:ro
    restart: unless-stopped

Then add to ~/.config/goose/config.yaml:```yaml
extensions:
mcp-n8n-server:
type: streamable_http
uri: http://mcp-server:8000/mcp # Or http://localhost:8000/mcp
enabled: true
timeout: 300


#### 4. Verify Connection

Once configured, start Goose and verify the connection:```bash
goose

In the Goose interface, you should see the n8n workflows available as tools. You can list them with:```
list tools


#### 5. Using n8n Workflows in Goose

Once connected, you can invoke n8n workflows directly from Goose:```
use tool chat_workflow with {&quot;chatInput&quot;: &quot;Hello from Goose!&quot;}

Or simply ask Goose to use the workflow:```
Run the chat_workflow with the message "analyze this data"


Goose will automatically call the appropriate n8n workflow through the MCP server.

### Other MCP Clients

This server implements the standard MCP protocol with HTTP transport and should work with any MCP-compatible client:

- **Claude Desktop**: Add to `claude_desktop_config.json`
- **Continue.dev**: Configure in Continue settings
- **Custom clients**: Connect to `http://host:port/mcp`

Example for Claude Desktop (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):```json
{
  &quot;mcpServers&quot;: {
    &quot;n8n-workflows&quot;: {
      &quot;url&quot;: &quot;http://localhost:8000/mcp&quot;,
      &quot;transport&quot;: &quot;http&quot;,
      &quot;description&quot;: &quot;n8n workflow integration&quot;
    }
  }
}

Workflow Authentication

Basic Authentication

For workflows requiring Basic Auth:

  1. Generate base64 credentials:```bash
    echo -n "username:password" | base64

2. Add to workflow config:```json
{
  &quot;name&quot;: &quot;secure_workflow&quot;,
  &quot;auth_type&quot;: &quot;basic&quot;,
  &quot;basic_auth&quot;: &quot;dXNlcm5hbWU6cGFzc3dvcmQ=&quot;,
  ...
}

Header Authentication

For workflows requiring custom header authentication:```json
{
"name": "api_workflow",
"auth_type": "header",
"auth_header_name": "X-API-Key",
"auth_header_value": "your-api-key-here",
...
}


### Global vs Workflow-Specific Authentication

- Set global authentication via environment variables (applies to all workflows)
- Override with workflow-specific settings in `workflows.json`
- Workflow-specific settings take precedence over global settings

## Monitoring

### Logs

View logs in Kubernetes:```bash
kubectl logs -f deployment/n8n-mcp-server

View logs in Docker:```bash
docker logs -f n8n-mcp-server


### Health Checks

The server includes health check endpoints for Kubernetes:
- Liveness probe: HTTP GET on port 8000
- Readiness probe: HTTP GET on port 8000

## Troubleshooting

### Common Issues

1. **Connection refused to n8n**
   - Check that `N8N_BASE_URL` is correct
   - Verify n8n is accessible from the container/pod
   - In Kubernetes, use service DNS names

2. **Workflow not found**
   - Verify workflow configuration is loaded
   - Check logs for configuration errors
   - Ensure `workflows.json` is properly mounted

3. **Authentication failures**
   - Verify credentials are correctly base64-encoded
   - Check that auth headers match n8n requirements
   - Review logs for authentication-related errors

4. **Port conflicts**
   - Change `SERVER_PORT` if 8000 is in use
   - Update NodePort in service.yaml if 30888 conflicts

5. **Goose not connecting to MCP server**
   - Verify the MCP server is running: `curl -X POST http://localhost:8000/mcp -H &quot;Content-Type: application/json&quot; -d &#x27;{&quot;jsonrpc&quot;:&quot;2.0&quot;,&quot;id&quot;:1,&quot;method&quot;:&quot;initialize&quot;,&quot;params&quot;:{}}&#x27;`
   - Check your Goose configuration at `~/.config/goose/config.yaml`
   - Verify the extension is enabled: `enabled: true`
   - Check the URI is correct: `uri: http://localhost:8000/mcp` (or NodePort 30888 for K8s)
   - Verify the type: `type: streamable_http`
   - Try restarting Goose after configuration changes
   - Check Goose logs: Run `goose` with verbose mode or check console output

6. **Goose can&#x27;t find n8n workflows**
   - Check that workflows are loaded: `docker logs n8n-mcp-server`
   - Use Goose&#x27;s `list tools` command to see available tools
   - Verify the MCP server has access to n8n (test with curl)

7. **Docker can&#x27;t reach n8n on localhost**
   - Use `host.docker.internal` instead of `localhost` in Docker
   - Set `N8N_BASE_URL=http://host.docker.internal:31678`
   - On Linux, you may need to use `--network=host` for the container

## Development

### Project Structure```
mcp-n8n-server/
├── server.py                  # Main MCP server implementation
├── requirements.txt           # Python dependencies
├── workflows.json             # Workflow configuration examples
├── Dockerfile                 # Docker image definition
├── docker-compose.yml         # Docker Compose configuration
├── .dockerignore              # Docker build exclusions
├── .env.example               # Environment variables template
├── .gitignore                 # Git exclusions
├── Makefile                   # Build and deployment commands
├── build-and-push.sh          # Automated build and push script
├── goose-mcp-config.json      # Example Goose MCP configuration
├── k8s/                       # Kubernetes manifests
│   ├── deployment.yaml        # Deployment + ConfigMap + Secret
│   └── service.yaml           # Service (NodePort 30888)
└── README.md                  # This file

Adding New Workflows

  1. Add workflow configuration to workflows.json
  2. Restart the server to load new configuration
  3. The workflow will be automatically exposed as an MCP tool

Extending the Server

The server can be extended to:
- Add resource providers for n8n workflow results
- Implement prompt templates for workflow guidance
- Add caching for frequently-used workflows
- Support webhooks with GET requests

License

MIT License

Contributing

Contributions are welcome! Please open an issue or submit a pull request.

Support

For issues and questions:
- GitHub Issues: /issues
- n8n Documentation: https://docs.n8n.io/
- MCP Protocol: https://modelcontextprotocol.io/

Test

goose run --provider ollama --model qwen3:4b -t "ask n8n workflow what candy colors are best"

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
MCP N8n Server 5d3819d1 怎么安装?

在客户端按下面的安装命令接入:docker run -d -p 8000:8000 \。装完在客户端配置里引用同一个包或端点。

MCP N8n Server 5d3819d1 怎么在 Claude Desktop、Claude 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

MCP N8n Server 5d3819d1 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

MCP N8n Server 5d3819d1 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

MCP N8n Server 5d3819d1 支持哪些客户端?

资料标注支持 Claude Desktop、Claude;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

MCP N8n Server 5d3819d1 能提供哪些能力?

资料显示能力标签包括 工作流自动化、HTTP服务、Docker、Claude。具体工具清单以官方文档为准。

MCP N8n Server 5d3819d1 需要什么运行环境?

运行时为 Docker;属于本地进程,需要在本机装好运行环境。

MCP N8n Server 5d3819d1 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-17。