@splice-cad/mcp

MCP server for Splice CAD cable assembly and wiring harness design tool. Lets AI agents search parts, build harness plans, create components with rich specs, and generate manufacturing documentation.

Works with Claude Code, ChatGPT, Cursor, Windsurf, Codex CLI, and any MCP-compatible client.

Beta — Splice CAD is currently in beta. Request access to get started.

Installation

From npm (coming soon):

npx @splice-cad/mcp

From source:

git clone https://github.com/splice-cad/splice-cad-mcp.git
cd splice-cad-mcp
npm install
npm run build

Then point your MCP config to the built file:

"command": "node",
"args": ["/path/to/splice-cad-mcp/dist/index.js"]

Requirements:

• Node.js 18+

• A Splice CAD account with an API key (generate in Account > API Key)

Related MCP server: solidworks-mcp

Quick Install

Claude Code (one command):

claude mcp add splice-cad -e SPLICE_API_URL=https://splice-cad.com -e SPLICE_API_KEY=your-key -- npx @splice-cad/mcp

For other tools, see the setup sections below.

Setup

Claude Code

// ~/.claude/mcp.json
{
  "mcpServers": {
    "splice-cad": {
      "command": "npx",
      "args": ["@splice-cad/mcp"],
      "env": {
        "SPLICE_API_URL": "https://splice-cad.com",
        "SPLICE_API_KEY": "your-api-key"
      }
    }
  }
}

Auto-approve all tools:

claude config add permissions.allow "mcp__splice-cad__*"

Cursor

// .cursor/mcp.json
{
  "mcpServers": {
    "splice-cad": {
      "command": "npx",
      "args": ["@splice-cad/mcp"],
      "env": {
        "SPLICE_API_URL": "https://splice-cad.com",
        "SPLICE_API_KEY": "your-api-key"
      }
    }
  }
}

Windsurf

// ~/.windsurf/mcp.json
{
  "mcpServers": {
    "splice-cad": {
      "command": "npx",
      "args": ["@splice-cad/mcp"],
      "env": {
        "SPLICE_API_URL": "https://splice-cad.com",
        "SPLICE_API_KEY": "your-api-key"
      }
    }
  }
}

ChatGPT (Developer Mode)

In ChatGPT settings, add an MCP server:

• Command: npx @splice-cad/mcp

• Environment: SPLICE_API_URL=https://splice-cad.com, SPLICE_API_KEY=your-key

OpenAI Responses API

import openai

response = openai.responses.create(
    model="gpt-4.1",
    input="Build me a 4-pin Deutsch DT connector harness",
    tools=[{
        "type": "mcp",
        "server_label": "splice-cad",
        "server_url": "npx @splice-cad/mcp",
        "require_approval": "never",
        "headers": {
            "SPLICE_API_URL": "https://splice-cad.com",
            "SPLICE_API_KEY": "your-api-key"
        }
    }]
)

Codex CLI

codex --mcp splice-cad="npx @splice-cad/mcp"

Environment Variables

Prompts

Context Prompts

Set the agent's operating mode — which tools to use, which to avoid, and the correct workflow:

Task Prompts

Step-by-step workflows that include their operating context:

Tools (27)

Parts & Components

Projects & Plans

Legacy Harnesses

Live Bridge (WebSocket)

Resources

Examples

See EXAMPLES.md for detailed walkthroughs including:

• Terminal blocks with ferrule terminations

• Importing from a CSV wiring schedule

• Live: generating a cable assembly from a datasheet PDF

• Live: reading a KiCad schematic and creating 21 connectors across 4 pages

• Live: reviewing and fixing an open plan

Architecture

There are two communication paths — one to the Splice cloud, one entirely local:

Single agent (default — embedded bridge):

  ┌──────────────┐    stdio     ┌──────────────────┐
  │  AI Agent    │◄────────────►│  MCP Server      │
  │  (Claude,    │              │  (splice-cad)    │
  │   Cursor,    │              │                  │
  │   ChatGPT)   │              │  ┌────────────┐  │
  └──────────────┘              │  │ WS Bridge  │  │
                                │  │ :9876      │  │
                                │  └─────┬──────┘  │
                                └────────┼─────────┘
                                         │ WebSocket (localhost)
                                ┌────────▼─────────┐
                                │  Splice Browser  │──── HTTPS ───► splice-cad.com
                                │  Tab             │
                                └──────────────────┘

Multi-agent (standalone splice-bridge):

  Agent A          Agent B
     │                │
  MCP Server A    MCP Server B     (both connect as WS clients)
     │                │
     └──── splice-bridge ────┘     ← Rust binary on :9876
                │
         ┌──────┴──────┐
     Tab 1 (proj A)  Tab 2 (proj B)

REST Tools (save_plan, search_connectors, etc.)

These make HTTPS requests to the Splice API at splice-cad.com. Your API key authenticates each request. Data travels over the internet. These work without a browser open.

Live Bridge Tools (execute_command, get_live_state, etc.)

These communicate entirely on your local machine:

1. The MCP server starts a WebSocket server on localhost:9876

2. The Splice browser tab connects to it (when Agent Bridge is enabled)

3. Agent commands flow: Agent → MCP process → WebSocket → Browser tab

4. The browser executes commands — same as clicking in the UI

5. Canvas updates instantly, actions appear in undo history

No data leaves your machine for live bridge commands. The WebSocket connection is localhost only — it never touches the internet. The Splice CAD cloud is not involved in live command execution.

Multi-Agent Mode (splice-bridge)

For running multiple agents on different projects simultaneously, use the standalone splice-bridge router:

  Agent A (Claude Code)          Agent B (Cursor)
       │                              │
  MCP Server A                   MCP Server B
       │                              │
       └────────── splice-bridge ─────┘    ← standalone Rust binary
                       │
            ┌──────────┴──────────┐
            │                     │
       Browser Tab 1         Browser Tab 2
       (project:abc)         (project:xyz)

The MCP server automatically detects if splice-bridge is already running on the bridge port. If so, it connects as a WebSocket client instead of starting its own embedded server. No configuration change needed — just start splice-bridge before launching your agents.

See the splice-bridge README for installation and usage.

What goes where

Security

API Key

Your Splice API key authenticates all REST API calls. It is:

• Stored only in your MCP config file (never sent to the AI agent or logged)

• Scoped to your user account — can only access your own projects and harnesses

• Revocable at any time from Splice Account > API Key

• Rate-limited by your subscription tier (weekly request quota)

Never commit your API key to git. Use environment variables or a local config file.

WebSocket Bridge

The WebSocket bridge runs on localhost only:

• No internet exposure — the WS server binds to 127.0.0.1, not 0.0.0.0

• Shared secret — the MCP server generates a random secret on startup and writes it to ~/.splice-bridge.json. The browser must send this secret to authenticate. This prevents other local processes from sending commands.

• One connection per namespace — if two tabs try to connect with the same namespace, the older one is disconnected

• Port configurable — change SPLICE_BRIDGE_PORT if 9876 conflicts with another service

What the AI agent can access

Through the MCP tools, the agent can:

• Read your projects, plans, harnesses, and parts (same as what you see in the app)

• Write plans and harnesses (create, modify, save — same as you editing in the UI)

• Execute commands on the live canvas (when bridge is connected)

• Search the shared parts database

The agent cannot:

• Access other users' private data

• Delete your account or change your password

• Access files on your computer (beyond what the AI client itself provides)

• Make network requests to anything other than the Splice API and localhost WebSocket

Recommendations

• Only enable the Agent Bridge when actively using it

• Review agent actions before saving — all live changes are undoable with Ctrl+Z

Development

Building

npm install
npm run build

Regenerating schemas (requires Splice frontend source)

SPLICE_FRONTEND_PATH=/path/to/splice/frontend npm run build:full

License

MIT