Skip to main content
Glama
@splice-cad/mcp

@splice-cad/mcp

Official
by splice-cad

@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: mcp-server-kicad

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

Available Tools

28 tools
create_cableA

Create a custom multi-conductor cable in the parts database. Use when a cable is not found via search — e.g. from a datasheet. Returns a part ID for BOM entries.

Inputs: mpn (required), cores (required), core_count (required), manufacturer (required), +4 more.

create_componentA

Create a component in the Splice parts database with full specs, images, and pin labels. Use lookup_part first to get image/datasheet URLs. Categories: "connector" (default), "circuit_breaker", "fuse", "relay", "contactor", "switch", "push_button", "motor", "pcb", "power_supply", "battery", "diode", "fan", "timer", "inductor", "capacitor", "resistor", "transformer", "solar_cell", "inverter", "flying_lead", "splice", "terminal_point", "other".

Inputs: mpn (required), positions (required), manufacturer (required), rows, +14 more.

create_harnessA

Create a new legacy harness. Provide the full WorkingHarness JSON with BOM and connection data. Read the harness_schema resource first. Returns the harness with harness_id and revision_id set.

Inputs: harness_data (required).

create_projectA

Create a new Splice project. Returns the project ID and details.

Inputs: name (required), description.

describe_commandA

Look up the exact params keys a bridge command accepts (for execute_command/execute_commands). Use this whenever unsure what params a command needs — the keys are NOT always the same as the constructor parameter names. Object params of a known PlanData type (e.g. link: PlanLink) are expanded to their nested fields, so required sub-fields like sourceNodeId/targetNodeId are shown.

Inputs: command (required).

execute_commandA

Execute a single command through the live WebSocket bridge. Works for both plan mode (project:* namespace) and assembly/harness mode (harness:* namespace). PREFER execute_commands (plural) for batching — much faster. Canvas updates immediately, action added to undo history.

Inputs: params (required), command (required), namespace.

execute_commandsA

PREFERRED over execute_command. Execute multiple commands in a single call — much faster than calling execute_command repeatedly. All commands run atomically and undo as one action. Works for both plan (project:) and assembly (harness:) namespaces.

Inputs: commands (required), namespace, description.

generate_assemblyA

Generate a harness assembly from a plan by selecting which nodes and bundles to include. Returns the created harness ID. The assembly appears in Splice as an editable harness linked to the project.

Inputs: name (required), link_ids (required), node_ids (required), project_id (required), +1 more.

get_category_templatesA

Get default properties, specs, and SVG templates for all component categories (fuse, relay, circuit breaker, etc.). Use this to discover what category-specific fields are available when creating components.

Inputs: no named parameters.

get_harnessA

Load a legacy harness with its full BOM (hydrated parts) and connection data. Use this to inspect or modify an existing harness.

Inputs: harness_id (required), revision.

get_harness_summaryA

Get a structured summary of a legacy harness: connectors, wires, cables, connections, and validation warnings. More concise than get_harness.

Inputs: harness_id (required).

get_live_stateB

Get or set live frontend state. Reflects all unsaved changes, including for assemblies (harness:* namespace). Use setComponentState to update the Component Creator form fields.

Inputs: query (required), params, namespace.

get_partB

Get full details for a specific part by ID, including its specification (pin count, gauge, etc.).

Inputs: id (required).

get_planA

Get PlanData for a project. WARNING: Can be very large for complex plans. PREFER get_plan_summary to understand plan state. Use node_ids/link_ids to fetch specific elements instead of the full plan.

Inputs: project_id (required), link_ids, node_ids, include_bom, +2 more.

get_plan_summaryA

PREFERRED way to read plan state. Returns components (with positions, pins, connection status, MPN), bundles, conductors, branch points, unconnected pins, and warnings. Much smaller than get_plan — use this first, only fetch full plan if you need raw data for specific elements.

Inputs: project_id (required).

get_projectA

Get a project with its plan and assembly list.

Inputs: project_id (required).

is_bridge_connectedA

Check which browser tabs are connected via the WebSocket bridge. Returns connected namespaces — project: for plans, harness: for assemblies. Use the namespace value with execute_command/get_live_state to target a specific tab.

Inputs: no named parameters.

list_harnessesA

List all legacy harnesses owned by the authenticated user. These are standalone harnesses not associated with a project.

Inputs: no named parameters.

list_projectsA

List all projects owned by the authenticated user.

Inputs: no named parameters.

lookup_partA

Look up a real-world part on DigiKey by MPN. Returns image URL, datasheet URL, specs, and parameters. Use this to enrich components before creating them with create_component.

Inputs: mpn (required), manufacturer.

redoB

Redo the last undone command in the Splice frontend.

Inputs: namespace.

save_harnessA

Save (overwrite) a legacy harness. The harness_data must include harness_id and revision_id from the loaded harness. Use get_harness first to load current state, modify it, then save.

Inputs: harness_id (required), harness_data (required).

save_planA

Save (overwrite) the PlanData JSON for a project. The plan_data must be a complete, valid PlanData object. Read the plan_schema resource first to understand the structure. Use get_plan to fetch the current state before modifying.

Inputs: plan_data (required), project_id (required).

search_cablesA

Search the Splice cable parts database. Only use when the user asks to find a cable in the database. For most cases, create cable BOM entries directly. Supports "4 core shielded 20 awg", "belden 2 conductor".

Inputs: query (required), limit, offset.

search_connectorsA

Search the Splice connector parts database. Only use this when the user asks you to find a part in the database, or when you need a sourcePartId for linking. For most cases, prefer creating BOM entries directly with the MPN/manufacturer you already know (from datasheets, user input, or web research). Supports fuzzy queries like "molex 24 pin male".

Inputs: query (required), limit, offset.

search_wiresA

Search the Splice wire parts database. Only use when the user asks to find a wire in the database. For most cases, create wire BOM entries directly with gauge/color you already know. Supports "22 awg red", "18 awg black white stripe".

Inputs: query (required), limit, offset.

undoA

Undo the last command in the Splice frontend.

Inputs: namespace.

validate_planA

Validate a project's plan for structural issues: orphan nodes, dangling conductors, missing parts, invalid references, mating compatibility, terminal point wiring, and shape/category consistency. Returns structured findings — each with a machine code, severity, involved node/conductor/link/mate IDs, and (where applicable) a suggestedFix — so an agent can triage or auto-resolve them. warnings is a flat list of the human-readable messages for back-compat.

Inputs: project_id (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 28 tools

    Disambiguation4/5

    Most tools clearly target a distinct resource and action, and the descriptions actively steer agents toward the preferred choice (e.g. PREFER get_plan_summary, PREFER execute_commands). A few pairs could still cause misselection — get_project vs get_plan vs get_plan_summary, get_harness vs get_harness_summary, and the search_* tools vs lookup_part — but the boundaries are explained well enough to recover.

    Naming Consistency4/5

    The set overwhelmingly follows a consistent verb_noun snake_case convention: get_part, create_project, save_plan, search_wires, validate_plan, list_harnesses. Minor deviations include the bare verbs undo/redo and get_live_state, which both gets and sets state despite its get_ prefix.

    Tool Count3/5

    At 28 tools, this sits above the borderline 16-25 range and will feel heavy for an agent to navigate. However, the count is defensible because the tools cluster into four coherent functional areas — parts database, projects/plans, legacy harnesses, and the live WebSocket bridge — with no true duplicates, though it bundles what could plausibly be separate servers.

    Completeness4/5

    Core workflows are solidly covered: part creation with enrichment (lookup_part → create_component), project lifecycle, plan read/summarize/validate, assembly generation, and legacy harness CRUD. The notable gaps are the total absence of delete operations across all resources and no update path for parts, which agents can partially work around via the live state and frontend tools.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      A
      maintenance
      This MCP server enables AI agents to understand and analyze electrical schematics from Cadence and Altium for comprehensive design reviews through natural conversations.
      11
      677 npm
      68
      Apache 2.0
    • A
      license
      A
      quality
      A
      maintenance
      MCP servers for KiCad schematic, PCB, symbol, footprint, and project automation, enabling AI-assisted electronic design via tools for read/write, analysis, and exports.
      109
      349 PyPI
      16
      GPL 3.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server for creating, modifying, and analyzing KiCAD schematic files using natural language.
      22
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that gives AI agents end-to-end control of KiCad 9+ for rule checks, manufacturing exports, production-readiness certification, and live PCB editor control.
      MIT