@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)

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

| Variable | Required | Description | |----------|----------|-------------| | SPLICE_API_URL | Yes | Splice backend URL | | SPLICE_API_KEY | Yes | API key (Account > API Key in Splice) | | SPLICE_BRIDGE_PORT | No | WebSocket bridge port (default: 9876) | | SPLICE_BRIDGE_SECRET | No | Shared secret for WS auth (auto-generated) |

Prompts

Context Prompts

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

| Prompt | Mode | Description | |--------|------|-------------| | plan-live | WebSocket | Work on a plan open in the browser — live canvas updates with undo/redo | | component-creator-live | WebSocket | Work in the Component Creator — update form, specs, SVG, and pins in real-time | | api-mode | REST API | No browser needed — create projects, build plans, search parts, manage harnesses |

Task Prompts

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

| Prompt | Mode | Description | |--------|------|-------------| | build-harness | API | Build a complete cable harness from a description or datasheet | | create-component | API | Create a part with specs, image, pin labels from an MPN or datasheet | | review-live-plan | Live | Connect via WebSocket, read live plan state, suggest improvements | | cleanup-layout | Live | Read component positions and reorganize for better layout | | import-from-spreadsheet | API | Build a harness from a CSV/Excel wiring schedule |

Tools (27)

Parts & Components

| Tool | Description | |------|-------------| | search_connectors | Fuzzy search ("molex 4 pin", "deutsch dt") | | search_wires | Fuzzy search ("22 awg red") | | search_cables | Fuzzy search ("4 core shielded") | | get_part | Full part details by ID | | create_component | Create with images, specs, SVG, pin labels | | create_cable | Create multi-conductor cable | | lookup_part | DigiKey lookup (images, datasheets, specs) | | get_category_templates | Default specs per component category |

Projects & Plans

| Tool | Description | |------|-------------| | list_projects | List user's projects | | create_project | Create new project | | get_project | Get project with plan and assemblies | | get_plan | Get plan data (filterable) | | save_plan | Save PlanData JSON (auto-corrects colors) | | get_plan_summary | Components, pins, connections, warnings | | validate_plan | Check for structural issues | | generate_assembly | Generate harness from plan selection |

Legacy Harnesses

| Tool | Description | |------|-------------| | list_harnesses | List standalone harnesses | | create_harness | Create from WorkingHarness JSON | | get_harness | Load with hydrated BOM | | save_harness | Save modified harness | | get_harness_summary | Compact summary |

Live Bridge (WebSocket)

| Tool | Description | |------|-------------| | is_bridge_connected | Check connected browser tabs | | execute_command | Single command (live canvas update) | | execute_commands | Batch (atomic, single undo) | | undo / redo | Undo/redo in browser | | get_live_state | Query live state (plan, component, SVG) |

Resources

| URI | Description | |-----|-------------| | splice://schema/plan-data | PlanData JSON schema + behavioral rules | | splice://schema/harness-data | WorkingHarness schema | | splice://examples/plans | Real-world harness patterns |

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

| Action | Path | Data leaves machine? | |--------|------|---------------------| | Search parts | HTTPS → splice-cad.com | Yes | | Save/load plan | HTTPS → splice-cad.com | Yes | | Create component | HTTPS → splice-cad.com | Yes | | execute_command (live) | WebSocket → localhost:9876 | No | | get_live_state (live) | WebSocket → localhost:9876 | No | | undo / redo (live) | WebSocket → localhost:9876 | No |

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