# The MCP server

> Connect Claude, ChatGPT, Codex or any MCP client to Wiring Studio. Sign in once with OAuth and an AI assistant can read and edit your harness projects.

Source: https://wiring.studio/docs/mcp-server/

The MCP server lets an AI assistant work inside your Wiring Studio account. Point Claude, ChatGPT, Codex or any other MCP client at one hosted address, sign in once in the browser, and the assistant can list your projects, read a sheet, place components, wire cavities, run the design rule checks and look at what it has drawn — as you, with exactly the access you already have.

## What it is

The Model Context Protocol is a standard way for an AI assistant to call tools inside another application. Wiring Studio runs an MCP server at a fixed address, so there is nothing to install, host or keep running — you give a client the address, sign in, and the assistant has 59 tools covering the same project data you work with on the canvas.

It acts as you. Every call is made under your own account, so the assistant sees the workspaces you belong to and nothing else, and its edits are your edits: they appear on the canvas immediately, and for everyone else in the project, through the same [real-time sync a team works through](https://wiring.studio/docs/collaboration/#workflows) and exactly as if you had drawn them yourself. Workspace, project and sheet are arguments on the tools, so the assistant has to say which sheet it is working on rather than inheriting whatever you happen to have open.

> **Note:** There is no API key to generate and no token to paste anywhere. The first time a client contacts the server it is turned away and told where to sign in, registers itself, and opens a browser window for the same Wiring Studio sign-in you use everywhere else. The client keeps the result — you never handle a credential.

## What you can do

The 59 tools fall into ten groups. The read tools return structured data an assistant can reason about; the write tools change the project.

| Group | Tools |
| --- | --- |
| **Workspaces** | list_workspaces |
| **Projects and sheets** | list_projects, get_project, create_project, rename_project, create_sheet, rename_sheet, set_project_settings |
| **Parts library** | search_parts, get_part, list_manufacturers, upsert_part |
| **Components** | get_sheet, add_component, update_component, delete_component, set_pin_layout, set_mating_connectors, add_extra_part, update_extra_part, delete_extra_part |
| **Wiring and pins** | list_wires, connect_wire, update_wire, delete_wire, set_twisted_pair, clear_twisted_pair, rename_network, set_pin, fill_pins, get_pin_config |
| **Cables, shielded cables and labels** | list_cables, add_cable, update_cable, delete_cable, set_cable_layers, list_shielded_cables, add_shielded_cable, update_shielded_cable, delete_shielded_cable, add_label, update_label, delete_label |
| **Reports and rules** | get_bom, get_cutlist, run_drc, list_drc_rules, set_drc_rules, auto_layout, derive_cables_from_wires |
| **Layout** | get_layout, move_components, transform_components, set_route, split_cable, scale_layout |
| **Assemblies** | insert_assembly, save_as_assembly |
| **Screenshots** | screenshot_sheet |

Names, arguments and descriptions travel over the connection itself, so the list your client shows you is the authoritative one. The table above is a map of the ground it covers, not a schema to code against.

## What to ask for

The tool list is a map, not a suggestion. What follows is the work people actually hand over — the jobs that are slow because they are wide rather than difficult, where a person is the bottleneck only because somebody has to walk every row. Each one names the tools it leans on and the thing that will trip it up. The last two are not edits at all: they are questions you would otherwise answer by tracing the drawing by eye.

### Fill the library from a catalogue

Getting a parts library populated is the wall most harness tools hit on day one: cavity counts, contact gauge ranges, seals and prices, typed in from supplier PDFs. Point an assistant at the catalogue or datasheet instead and it can write the parts in directly with **upsert_part**, one per part number, across any of the sixteen categories. Only the part number, category and manufacturer are required, and it needs no paid plan — a Free personal workspace can take a full catalogue.

> **Warning:** **upsert_part** replaces a part, it does not patch it. Anything left out goes back to its default, so a price-only update on a twelve-way connector silently resets it to one cavity and clears its mates in every project that used it. Read the part with **get_part** first and send the whole set of properties back. Part images and contact-arrangement drawings are not part of the tool surface at all, so an imported catalogue arrives without them.

### Replace a part that has gone end of life

When a connector is discontinued the hard part is not choosing the replacement, it is finding every place the old one is used before one slips through into production. An assistant can walk **list_projects**, **get_project** and **get_sheet**, then repoint each use in turn: **update_component** for components, **update_wire** for wires, **set_pin** and **fill_pins** for contacts and seals, **update_cable** for coverings, **update_label**, **update_extra_part** and **update_shielded_cable** for the rest.

> **Note:** There is no single find-and-replace call, and each of those objects holds its own part reference, so a widely used part means one write per use against a limit of sixty calls a minute. Repointing a component changes which part it is, not how many cavities it has — swap a twelve-way for an eight-way and the wires on the cavities that no longer exist survive as errors. Finish with **run_drc** and fix what it names.

### Build a project from your own spreadsheet

[Excel import](https://wiring.studio/docs/excel-import/) reads a workbook cold and infers what the columns mean. Your own wire list does not need inferring — you already know that column D is the cavity and that a dash in the reference means a splice. Write those conventions down once as a prompt or a saved skill, and an assistant can read the file on your terms and build the project with **create_project**, **add_component**, **connect_wire**, **fill_pins**, **add_cable** and **add_label**.

> **Note:** Parts have to exist before the components that use them, so run the catalogue pass first. **create_project** already returns a first sheet — calling **create_sheet** for it wastes a call and fails outright on Free, which allows one sheet per project. A project still being built by Excel import is read-only until it finishes, and **get_project** reports that as **importing**.

### Re-price a library and re-quote

Prices go stale between revisions and a bill of materials retyped by hand goes stale faster. Price lives on the library part, which is shared by every project in the workspace, so one **upsert_part** per part propagates everywhere. **get_bom** and **get_cutlist** then report what the harness costs, and **set_project_settings** carries the per-project **priceMultiplier** and **cutlistMultiplier** that turn cost into a quote.

> **Note:** **search_parts** returns at most a hundred parts and has no pagination, so ask for one category at a time rather than for the library. The **part-no-price** and **part-no-number** checks are the quickest way to find what is blocking a clean quote — both look at the whole project, not one sheet.

### Make the naming consistent

Signal names drift: a net gets renamed on one sheet and not the next, or a convention changes halfway through a programme. **rename_network** is project-scoped rather than sheet-scoped, so one call renames every wire in the net wherever it lives and reports how many it touched. Pair it with **list_wires** to audit first. It is worth running after any pass that repoints wire endpoints, since moving an end does not re-derive the net name.

### Fix what the design rule checks find

Faults found at the crimp bench cost far more than faults found at the desk. **run_drc** returns every violation with its rule, severity, message and subject, and most rules have an edit behind them: **cable-no-length** goes to **update_cable**, **contact-missing** to **fill_pins**, **part-no-price** to **upsert_part**, **cable-no-route** to **set_route** or **auto_layout**. Ask for a pass and the assistant can triage the list and fix the ones that are mechanical.

> **Note:** Violations are located by name rather than by an internal id, which is the same vocabulary the write tools take. Wire subjects spell the endpoint with the cavity label, though, so fixing one usually needs **get_pin_config** to map the label back to the cavity number. At most a hundred violations come back in one call — the counts stay complete and **truncated** says when the list was cut — and a project over six hundred components is refused, because that check belongs in the app.

### Reuse a sub-harness across programmes

Most teams redraw the same power branch or the same ground stud arrangement on every programme. **save_as_assembly** snapshots named components — or a whole sheet — with their wiring, pin assignments, shielded cables, labels and extra parts intact, and **insert_assembly** deep-copies it into any project at a position you give, reporting anything it had to rename to avoid a collision. Saving one counts against the reusable-component allowance on your plan, and inserting an assembly into a different workspace leaves its part references unresolved.

### Turn a wire list into a drawing

A schematic that is electrically complete is still not something a bench can build from. **derive_cables_from_wires** creates a design edge everywhere wires run but no cable is drawn, **add_cable** and **update_cable** put real lengths on them, and **scale_layout** re-flows the sheet so what is drawn is proportional to what will be cut. **auto_layout** rearranges for legibility, **split_cable** inserts a branch point or an inline splice partway along a run, and **screenshot_sheet** shows you — and the assistant — what came out.

### Trace a colour-coded wire

On the bench the question is never abstract: somebody is holding a red wire with two white bands and wants to know where the other end lands. **list_wires** returns every wiring edge on a sheet with both endpoints as a component name and a cavity number, along with the wire part it uses and the marking bands on it, so an assistant can find the run and tell you where it goes. **get_pin_config** turns the cavity number into the label printed on the connector, and **screenshot_sheet** points at it on the drawing. [Wire colours and marking](https://wiring.studio/docs/wire-colors-and-marking/) covers how the colours are set in the first place.

> **Note:** Colour is not on the wire, it is on the library part. **list_wires** gives you **wirePartNumber**, and the colour is the hex value in **props.wire.color** that **get_part** returns. **search_parts** matches part numbers, descriptions and manufacturers rather than colour, so asking for the red wire works when your wire parts say red somewhere in their description and needs the part number when they do not. The bands in **colorCodePartNumbers** are separate heat-shrink parts, and the colour on a twisted pair's **group** is the pair's own, not either wire's.

### Answer what a network connects

A net is the question people actually ask of a harness: what else is on CAN-H, what shares this ground, what goes dark if this cavity is wrong. **list_wires** carries **networkName** on every edge, so an assistant can group a sheet's wires by net and read the members straight off it, with both endpoints already named. **get_sheet** gives each connector its mate, which is how a net leaves one sheet for the next.

> **Note:** There is no single call that returns a network. **list_wires** shows one sheet at a time, so a net that crosses a mated connector pair means one call per sheet and stitching the halves together — a mate joins pin to pin by number, including across sheets. Wires that were never named come back with **networkName** null and have to be walked endpoint to endpoint. Network names are not unique either, so two unrelated nets can answer to the same one. **rename_network** is the single net-wide operation, and it reports how many wires it touched.

## Before you start

- **Any plan can connect**, Free included. There is no separate purchase and no MCP seat.
- **The assistant sees every workspace you belong to**, personal and organisation alike. It cannot reach a workspace you are not a member of.
- **Writing into an organisation workspace needs the Team plan.** Below it the organisation is read-only over MCP, exactly as it is in the app, and every edit is refused.
- **It reads and it writes.** Creating, editing and deleting are all available, and none of it asks you to confirm a second time.
- **Your plan limits still apply to what it creates**, refused in the same way and for the same reasons as in the app. See [Pricing and plans](https://wiring.studio/docs/pricing-and-plans/).
- **A project still being built by [Excel import](https://wiring.studio/docs/excel-import/) is read-only** until that import finishes.

The client you connect is third-party software running under someone else's terms, and your project data goes to whichever model provider is behind it. What Wiring Studio itself records is set out in section 1.5 of the [privacy policy](https://wiring.studio/privacy-policy/#collect), and the services involved are listed on the [subprocessors](https://wiring.studio/subprocessors/) page.

> **Warning:** Edits made over MCP are immediate. There is no dry run and no review step — the assistant writes straight into the live project, and everyone else in it sees the change at once. Point a client at a scratch project first and learn how it behaves before letting it near real work.

## Connect Claude

Every client needs the same one thing, the server address.

**Server URL**

```text
https://mcp.wiring.studio/mcp
```

### Claude Code

**Terminal**

```bash
claude mcp add --scope user --transport http wiring-studio https://mcp.wiring.studio/mcp
```

1. Run the command above. **--scope user** makes the server available in every project on your machine.
2. In a session, type **/mcp**, choose **wiring-studio** and sign in. **claude mcp login wiring-studio** does the same from the terminal.
3. Ask Claude to list your workspaces, which is the cheapest way to confirm the connection works.

Use **--scope project** instead and the server is written into a shareable **.mcp.json** in the repository, which colleagues approve and sign into with their own accounts.

**.mcp.json**

```json
{ "mcpServers": { "wiring-studio": { "type": "http", "url": "https://mcp.wiring.studio/mcp" } } }
```

### Claude Desktop and claude.ai

1. Open **Customize ▸ Connectors** — on the web that is [claude.ai/customize/connectors](https://claude.ai/customize/connectors).
2. Click **+** and choose **Add custom connector**.
3. Name it **wiring-studio**, paste the server address, and leave the advanced settings empty.
4. Click **Add**, then complete the browser sign-in.
5. In a chat, open the **+** menu ▸ **Connectors** and switch **wiring-studio** on.

> **Note:** Custom connectors are available on Free, Pro, Max, Team and Enterprise, and Free allows one of them. On Team and Enterprise an owner adds the connector under **Organization settings ▸ Connectors** first; everyone else then clicks **Connect** and signs in as themselves.

> **Tip:** Claude reaches the server from Anthropic's cloud rather than from your own machine, which is why there is nothing to run locally and why the address has to be a public one. It is.

## Connect ChatGPT

### ChatGPT

1. Open **Settings ▸ Security and login** and turn **Developer mode** on.
2. Add a custom connector and give it the server address, https://mcp.wiring.studio/mcp.
3. Complete the browser sign-in when it appears.

Plus and Pro can turn developer mode on themselves. On Business, Enterprise and Edu a workspace admin has to enable it first, under **Workspace Settings ▸ Permissions & Roles**. Connectors in ChatGPT are available on the web only.

> **Note:** ChatGPT can only connect if its connector registers itself with our sign-in service the way the other clients on this page do, and that is not something we can confirm from our side. Treat these steps as a preview until it is: if the sign-in window never opens, the fault is the handshake rather than anything you have typed, and the other clients here are the dependable route in the meantime.

### Codex CLI

**Terminal**

```bash
codex mcp add wiring-studio --url https://mcp.wiring.studio/mcp
codex mcp login wiring-studio
```

The first command writes the entry below into **~/.codex/config.toml**; you can equally write it by hand and then run the login command.

**~/.codex/config.toml**

```toml
[mcp_servers.wiring-studio]
url = "https://mcp.wiring.studio/mcp"
```

## Other MCP clients

Any client that speaks streamable HTTP MCP and OAuth 2.1 with dynamic client registration works. Give it the server address and it arranges the rest itself — no headers to set, no keys to store, and nothing to configure beyond the URL.

**mcp.json**

```json
{ "mcpServers": { "wiring-studio": { "url": "https://mcp.wiring.studio/mcp" } } }
```

- **Cursor** — the shape above, in **~/.cursor/mcp.json** for every project or **.cursor/mcp.json** for one.
- **VS Code** — **.vscode/mcp.json**, where the top-level key is **servers** rather than **mcpServers**, and the entry carries **type: http** beside the URL.
- **Windsurf** — **mcp_config.json**, where the address goes under **serverUrl** rather than **url**.

The first thing the server does with a new client is refuse it. That refusal carries the address of the sign-in service, and it is how the handshake begins — every client here handles it without being told. Seeing one in a log is not a failure.

For a starting point to discover project tools and machine-readable documentation, see [API and developer resources](https://wiring.studio/docs/api/).

## Working with an agent

An assistant finds its way in the same order you would. **list_workspaces** gives it the workspaces you belong to, **list_projects** the projects in one of them, **get_project** the sheets in a project, and **get_sheet** everything on a sheet — components, cavities, cables and wires. After that it has the names it needs to change anything.

- “List my projects and tell me which ones have design rule violations.”
- “Add a 12-way connector to the engine sheet and wire cavity 1 through to the splice.”
- “Every wire between X1 and the splice should be black — fix the ones that are not.”
- “Produce the cut list for this project and tell me the three most expensive parts in the BOM.”
- “Trace the red wire out of X1 cavity 4 and tell me where it lands.”
- “What else is on the CAN-H network, and does any of it leave this sheet?”
- “Rename the network carrying CAN-H and make sure it is twisted with CAN-L.”
- “Tidy up the layout on sheet 2 and show me what it looks like.”

### Names, not ids

Sheet-scoped tools address things by the names you already see: a component by its name from **get_sheet**, a library part by its part number. There is no internal identifier to hunt down and none to paste — which also means that renaming a component in the app changes how an assistant has to refer to it.

### Leave alone or clear

Write tools follow one rule throughout. An argument the assistant leaves out is left alone; an argument it sets to null is cleared. That is the whole difference between not changing a label and removing one, and it is worth knowing when you read back what an assistant says it did.

> **Tip:** Ask for **run_drc** after a batch of edits, and for **screenshot_sheet** once the batch is done. The checks are the same ones the app runs, so an assistant that clears them is clearing what you would have seen on the [design rule checks](https://wiring.studio/docs/design-rule-checks/) card — and a screenshot is the only way it can tell whether the layout it produced actually looks right.

## Limits and safety

| Limit | What it means |
| --- | --- |
| **Deletes are canvas objects only** | Components, cables, wires, labels, extra parts and shielded cables. A library part, a project or a sheet can never be deleted over MCP — those stay things a person does in the app. |
| **Plan limits apply to creates** | Refused exactly as they are in the app. Deletes are deliberately never plan-limited. See [Pricing and plans](https://wiring.studio/docs/pricing-and-plans/). |
| **60 tool calls a minute** | Counted per person, across every client you have connected. Over the limit, the call comes back as an error telling the assistant to wait and try again. |
| **6 screenshots a minute** | **screenshot_sheet** has a budget of its own on top of the general one. A capture takes 10 to 40 seconds and returns a PNG whose longer side is between 512 and 4096 pixels, 1600 by default. |
| **100 design rule violations** | **run_drc** returns at most 100, and declines a project of more than 600 components outright. |
| **100 search results** | **search_parts** returns no more than that from the library at a time. |
| **Imports are read-only** | A project being built by Excel import is closed to writes until it finishes. |

**screenshot_sheet** is the one tool that goes further than the database: it signs a headless browser into your account, renders the canvas the way the app draws it, and signs that browser out again. The browser belongs to Cloudflare, listed on the [subprocessors](https://wiring.studio/subprocessors/) page.

> **Warning:** Nothing an assistant does is a draft. Every change is written to the live project and synced to everyone working in it at once, the same as a change you make yourself.

## Disconnecting

Wiring Studio keeps no list of connected clients. The connection lives in the client, so the client is where you end it.

**Terminal**

```bash
claude mcp remove wiring-studio
```

- **Claude Code** — the command above, which deletes the stored sign-in along with the server entry.
- **Claude Desktop and claude.ai** — remove the connector under **Customize ▸ Connectors**. On Team and Enterprise an owner removes it for the whole organisation.
- **ChatGPT** — remove the custom connector in settings.
- **Everything else** — delete the server's entry from the client's configuration file.

Removing the connection discards the sign-in the client was holding, and there is nothing left on the Wiring Studio side to clean up. An account with no client pointed at it is simply an account no assistant can reach.

_Last updated: 15 September 2026_