@splice-cad/mcp
OfficialClick on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@@splice-cad/mcp search for a Deutsch DT06-4S connector"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@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/mcpFrom source:
git clone https://github.com/splice-cad/splice-cad-mcp.git
cd splice-cad-mcp
npm install
npm run buildThen 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/mcpFor 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/mcpEnvironment:
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 |
| Yes | Splice backend URL |
| Yes | API key (Account > API Key in Splice) |
| No | WebSocket bridge port (default: |
| 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 |
| WebSocket | Work on a plan open in the browser — live canvas updates with undo/redo |
| WebSocket | Work in the Component Creator — update form, specs, SVG, and pins in real-time |
| 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 |
| API | Build a complete cable harness from a description or datasheet |
| API | Create a part with specs, image, pin labels from an MPN or datasheet |
| Live | Connect via WebSocket, read live plan state, suggest improvements |
| Live | Read component positions and reorganize for better layout |
| API | Build a harness from a CSV/Excel wiring schedule |
Tools (27)
Parts & Components
Tool | Description |
| Fuzzy search ("molex 4 pin", "deutsch dt") |
| Fuzzy search ("22 awg red") |
| Fuzzy search ("4 core shielded") |
| Full part details by ID |
| Create with images, specs, SVG, pin labels |
| Create multi-conductor cable |
| DigiKey lookup (images, datasheets, specs) |
| Default specs per component category |
Projects & Plans
Tool | Description |
| List user's projects |
| Create new project |
| Get project with plan and assemblies |
| Get plan data (filterable) |
| Save PlanData JSON (auto-corrects colors) |
| Components, pins, connections, warnings |
| Check for structural issues |
| Generate harness from plan selection |
Legacy Harnesses
Tool | Description |
| List standalone harnesses |
| Create from WorkingHarness JSON |
| Load with hydrated BOM |
| Save modified harness |
| Compact summary |
Live Bridge (WebSocket)
Tool | Description |
| Check connected browser tabs |
| Single command (live canvas update) |
| Batch (atomic, single undo) |
| Undo/redo in browser |
| Query live state (plan, component, SVG) |
Resources
URI | Description |
| PlanData JSON schema + behavioral rules |
| WorkingHarness schema |
| 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:
The MCP server starts a WebSocket server on
localhost:9876The Splice browser tab connects to it (when Agent Bridge is enabled)
Agent commands flow: Agent → MCP process → WebSocket → Browser tab
The browser executes commands — same as clicking in the UI
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 |
| WebSocket → localhost:9876 | No |
| WebSocket → localhost:9876 | No |
| 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, not0.0.0.0Shared 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_PORTif 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 buildRegenerating schemas (requires Splice frontend source)
SPLICE_FRONTEND_PATH=/path/to/splice/frontend npm run build:fullLicense
MIT
Available Tools
28 toolscreate_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
Scored across 28 tools
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.
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.
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.
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
Related MCP Connectors
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
One MCP server for the services your AI needs: memory, files, Microsoft 365, kanban and more.
Hosted MCP server connecting AI assistants to 9,000+ apps and 40,000+ actions via Zapier.
Related MCP Servers
- AlicenseAqualityAmaintenanceThis MCP server enables AI agents to understand and analyze electrical schematics from Cadence and Altium for comprehensive design reviews through natural conversations.11677 npm68Apache 2.0
- AlicenseAqualityAmaintenanceMCP servers for KiCad schematic, PCB, symbol, footprint, and project automation, enabling AI-assisted electronic design via tools for read/write, analysis, and exports.109349 PyPI16GPL 3.0
- AlicenseNot gradedqualityDmaintenanceMCP server for creating, modifying, and analyzing KiCAD schematic files using natural language.22MIT
- AlicenseNot gradedqualityDmaintenanceAn 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