DEV Community: Artyom Rabzonov

Claude Code MCP Server Setup on Windows

Artyom Rabzonov — Thu, 14 May 2026 10:59:46 +0000

How to Set Up an MCP Server in Claude Code on Windows

Add HTTP, SSE, and stdio MCP servers to Claude Code on Windows. The cmd /c npx wrapper, the three scopes, and the errors you hit if you skip the wrapper.

TL;DR: Use claude mcp add for remote HTTP servers without modification. Wrap any stdio server running through npx with cmd /c. Without the wrapper, npx fails to spawn and the server appears in claude mcp list but never connects.

Prerequisites

Claude Code installed. Run claude --version.
Node.js 18 or newer on PATH if you plan to run stdio servers via npx.
A working terminal. Windows PowerShell, Windows Terminal, or Git Bash. WSL is not required.

Pick a Scope Before You Add a Server

Scope	Loads in	Shared with team	Stored in
local (default)	Current project only	No	~/.claude.json
project	Current project only	Yes, via Git	.mcp.json in project root
user	All your projects	No	~/.claude.json

Option 1: Add a Remote HTTP Server (No Windows-Specific Quirks)

claude mcp add --transport http sentry https://mcp.sentry.dev/mcp

For servers that authenticate with a token:

claude mcp add --transport http github https://api.githubcopilot.com/mcp/ --header "Authorization: Bearer YOUR_GITHUB_PAT"

Option 2: Add a Local Stdio Server (Where Windows Differs)

On Windows, npx resolves to npx.cmd, a batch script the Node child-process spawn inside Claude Code does not invoke directly. The fix is to wrap the call with cmd /c.

Method A: Through the CLI

claude mcp add --transport stdio filesystem -- cmd /c npx -y @modelcontextprotocol/server-filesystem C:/Users/you/projects

All flags come before the server name. The double-dash -- separates the name from the command.

Method B: Edit .mcp.json Directly

{
  "mcpServers": {
    "filesystem": {
      "command": "cmd",
      "args": ["/c", "npx", "-y", "@modelcontextprotocol/server-filesystem", "C:/Users/you/projects"]
    }
  }
}

Use forward slashes in path arguments. Restart Claude Code after editing.

Verify the Server Is Connected

Run claude mcp list - the server should appear.
Inside Claude Code, type /mcp - servers show as connected, pending, or failed.
Use a tool to confirm the connection works end-to-end.

Common Errors

spawn npx ENOENT - add the cmd /c wrapper, or confirm Node is on PATH.
Server failed to start after OAuth - set MCP_TIMEOUT=10000 before launching Claude Code.
This project MCP servers must be approved - approve at the prompt, or run claude mcp reset-project-choices.
Server shows in list but never appears under /mcp - flag ordering is wrong; re-run with all options before the name.

FAQ

Why does npx fail on Windows? On Windows it resolves to npx.cmd, a batch script the Node child-process spawn does not invoke as an executable. Wrapping with cmd /c hands the script to the shell.

Where is the MCP config file stored on Windows? Local and user-scoped servers live in %USERPROFILE%\.claude.json. Project-scoped servers live in .mcp.json at the project root.

Do I need WSL? No. The native Windows install of Claude Code runs MCP servers directly.

Originally published at automatelab.tech

What is MCP (Model Context Protocol)? A 2026 Primer

Artyom Rabzonov — Thu, 14 May 2026 10:51:46 +0000

TL;DR: The Model Context Protocol is an open standard that enables language models to interface with external tools and information sources through a unified JSON-RPC 2.0 mechanism.

How MCP Works

MCP operates through JSON-RPC 2.0 across a connection between three components:

Hosts - The language model application users interact with (Claude Desktop, Cursor, ChatGPT)
Clients - The connector within the host communicating with servers
Servers - Lightweight services exposing specific capabilities (GitHub, Slack, PostgreSQL, filesystem)

Each server provides three core capabilities:

Resources - Read-only contextual information
Prompts - Reusable templated prompts users can select
Tools - Functions models can invoke

Why MCP Exists: The M-by-N Problem

Previously, each language model application required custom integration with third-party tools. With M models and N tools, this created M x N necessary integrations. MCP reduces this to M+N. By early 2026, over 500 public MCP servers existed. Anthropic, OpenAI, and Google DeepMind all support the protocol.

MCP vs Zapier, Make, and n8n

Tool	Trigger Model	Best For
Zapier / Make	Event-driven	When Stripe payment arrives, post in Slack
n8n	Event-driven with self-hosting	Same plus custom logic and on-premises data
MCP	On-demand	Look up latest Stripe payments and draft refund email

How Automation Builders Use MCP Today

n8n MCP nodes. Any existing n8n workflow becomes available as an MCP tool to AI hosts.
Zapier MCP. Leverage existing Zap connections without rebuilding authentication.
Local servers in Claude Desktop or Cursor. Run a filesystem MCP server against a local folder.

FAQ

Who created MCP? Anthropic introduced MCP in November 2024 as an open protocol.

What distinguishes MCP from a regular API? MCP is a standardization layer providing AI hosts with consistent methods to discover capabilities, authenticate, and invoke functions.

Is MCP equivalent to Zapier? No. Zapier provides event-driven workflow automation. MCP enables on-demand tool access. Both work together.

Must I write code to use MCP with n8n? No. The MCP Client and MCP Server Trigger nodes feature visual configuration.

Is MCP secure? Security responsibility falls to the host. Only install MCP servers from trusted sources.

Originally published at automatelab.tech

n8n MCP Server: Build, Lint, and Debug Workflows From Your AI Agent

Artyom Rabzonov — Thu, 14 May 2026 10:49:41 +0000

Overview

"Install @automatelab/n8n-mcp, point your AI agent at it, and get nine tools that generate, lint, and diagnose n8n workflow JSON correctly the first time."

The package addresses a specific problem: generic language models produce n8n JSON that imports successfully but fails during runtime due to incorrect connection topology, deprecated node types, and silent data loss between nodes.

Nine Tools: Four Stateless, Five Live-Instance

Stateless tools (no n8n instance required):

n8n_generate_workflow - Converts plain English descriptions to workflow JSON with AI-Agent-aware topology
n8n_scaffold_node - Generates TypeScript files for custom node packages
n8n_lint_workflow - Identifies errors and warnings in workflow JSON
n8n_explain_execution - Diagnoses failed executions with per-node analysis

Live-instance tools (require API credentials):

n8n_list_workflows
n8n_get_workflow
n8n_create_workflow
n8n_activate_workflow
n8n_list_executions

Installation

npm install -g @automatelab/n8n-mcp

Requires Node 20 or later. API keys are optional for stateless tools.

Configuration Across Hosts

The standard MCP configuration block works for Cursor, Claude Desktop, Claude Code, Cline, and Windsurf:

{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@automatelab/n8n-mcp"],
      "env": {
        "N8N_API_URL": "https://your-n8n.example.com",
        "N8N_API_KEY": "n8n_..."
      }
    }
  }
}

Key Features

AI Agent Topology

The generator correctly wires AI Agent sub-nodes using typed connections (ai_languageModel, ai_memory, ai_tool) rather than defaulting to main connections that cause silent failures.

Linting Capabilities

The lint catches a small but high-value set: deprecated node types (function -> code, spreadsheetFile -> convertToFile), AI Agents missing a language model, IF-v1 schema, missing webhookId, broken connections.

Silent Data Loss Diagnosis

The explain tool identifies when nodes return zero items, causing downstream nodes to skip execution without errors - the top-cited n8n debugging pain point.

Comparison to Alternatives

This server focuses on first-run correctness and execution diagnosis. The alternative czlonkowski/n8n-mcp provides broader coverage with 20+ tools indexing all n8n nodes. Both can run simultaneously.

FAQ

Live instance required? No - four stateless tools work offline.

AI Agent import failures? Usually incorrect connection types; use the linter before importing.

Silent data loss? The explain tool flags zero-item handoffs with common cause hints.

API key location? Settings -> API -> Create API key in your n8n instance.

Originally published at automatelab.tech

Notion as the Control Plane: Per-Task Model Dispatch for Agent Workflows

Artyom Rabzonov — Tue, 12 May 2026 13:56:06 +0000

Most "AI for ops" tools fail in one of two ways. Fully autonomous agents go off the rails and ship the wrong thing. Draft-only assistants do 10% of the job and leave the breakdown, sequencing, and execution on you.

I wanted a third option: agents own decomposition and execution, humans own approval. The substrate is Notion, because that's where the work already lives.

This post is the pattern, not the pitch. The repo is at the bottom.

The problem with one-model-per-workflow

Direct LLM chat handles a single prompt well. It does not handle "launch the pricing page" well, because that isn't a prompt - it's a project. The model either improvises sub-steps in one long stream of consciousness, or you do the project management by hand and copy-paste between threads.

The fix is to separate three things that get conflated:

Decomposition - turning one task into a graph of subtasks with dependencies
Dispatch - choosing the right model for each subtask and running them in the right order
Approval - the human gate between planning and execution

Once those are separate, you can keep humans in the decision seat without making them babysit the work.

The loop

Four phases, all anchored in a single Notion task database:

Submit. Operator creates a task in Notion in plain language.
Plan. A planner agent reads the task and emits a subtask graph. Each subtask gets a description, a list of dependencies, and an explicit model tier.
Approve. The plan lands back in Notion as child pages. Operator reviews, edits, or rejects. Nothing dispatches without sign-off.
Execute. On approval, an orchestrator dispatches subtasks in parallel where the graph allows, sequentially where it doesn't. Each subtask runs on its assigned model. Outputs land back in the same Notion task tree.

A concrete example

A "launch the website" task decomposes into 21 subtasks across three model tiers:

Tier	Count	Work	Parallelism
Opus	1	Information architecture + outline	sequential (root)
Sonnet	4	Page copy drafts	parallel
Haiku	6	Asset/image prompts	parallel
Haiku	10	Directory submission entries	parallel

One operator approval. Twenty-one outputs back in Notion, ready for review.

Why per-task model assignment matters

Defaulting to the smartest model for every subtask is the easiest way to burn money on agentic workflows. Directory submissions don't need Opus reasoning. Architecture decisions shouldn't run on Haiku.

In practice, routing clerical work to Haiku and reserving Opus for the reasoning-heavy nodes cuts model spend roughly an order of magnitude, with no quality loss on the parts that matter.

Implementation notes

A few things that turned out to be load-bearing once I started running this daily:

The approval gate is doing real work. Without it, the planner occasionally invents subtasks or misjudges scope. With a 30-second human review, those get caught before they consume tokens.
Force the planner to declare dependencies explicitly. "Run in parallel where possible" only works if the planner outputs dependsOn: [] for every node. Implicit ordering doesn't survive contact with fan-out.
Give the planner a short rubric for tier selection. Without it, the planner over-picks the flagship "to be safe." A one-paragraph rubric in the system prompt (Haiku for clerical, Sonnet for writing, Opus for reasoning/architecture) is enough.
Notion as the substrate is the unlock. It means non-technical operators can drive the workflow, edit plans, and consume outputs without a custom UI.

Caveats

Not a fit if your team doesn't already live in Notion.
The pattern is strongest for parallel fan-out of independent subtasks. Workflows that need iterative refinement between two agents mid-run are weaker.
Once you fan out 10+ Haiku tasks at once, rate limits start mattering - back-pressure in the orchestrator is non-optional.

Repo

I've open-sourced the implementation:

github.com/ratamaha-git/agency-os

Happy to answer questions on the planner prompt shape, the dependency-graph schema, or the model-tier rubric.