MCP App Store
by KeenEthics
PCBKit icon

PCBKit MCP Server for ChatGPT

By PCBKit

Overview

PCBKit designs printed circuit boards with you. Describe what the board should do — "a USB-C powered sensor node with an ESP32 and a temperature sensor" — and it is written in PCBKit, a small board language with real units, built from proven circuit blocks (regulators, USB, microcontroller support, protection). PCBKit checks the design (electrical rules, clearances, the fab's limits), places the parts, routes the copper and fills the pours, then exports Gerber and drill files with the bill of materials and placement list for the fab, or a KiCad board to continue in KiCad. Ask for changes in plain words ("move the connector to the left edge", "make the power tracks wider") and it changes the board and routes it again. Works without an account: each conversation keeps one board you improve step by step, shown beside the conversation where you can edit and route it too. Sign in to keep your boards with your account and list them. Exported files are download links kept for 7 days. Limits: two-sided and multilayer boards of everyday size and density; very large or high-speed boards may not route completely, and PCBKit says which connections are missing. Review every design before you order it.

How to connect

  1. ChatGPT: Open the PCBKit listing in the ChatGPT app directory and choose Connect. ChatGPT listing PCBKit exposes 21 tools here.

Tools

analysis

ChatGPT
Physical answers with numbers, never by eye: lenses (run: power, current, heat, ready), calculations (calc: an LED's resistor, a divider, battery life, a bridge's heat), and ready analyses of the routed board (script { template }: impedance and returnpath for a bus or a pair, pdn and load for a supply's ripple and dips, response for a filter, converter and heatup for a regulator, crosstalk, reflections, eye, emissions, tolerance, planes). Changes nothing. Example: analysis { op: "script", why: "Is the CAN pair routed right?", template: "impedance" }. Ops: spice { source }; netlist { … }; inputs { … }; dcir { conductivity, curveTolerance, layerDepths, maxArea, maxVertices, net, plating, terminals }; electrothermal { ambientCelsius, componentWatts, electrical, material, thermal }; electrostatic { conductors, excited, relativePermittivity, xMetres, yMetres, … }; run { … }; script { … }; circuit { circuit, mode, … }; calc { kind, … }

analyze

ChatGPT
What the board means physically, computed from its copper and stackup: dc (voltage drop: each supply from its source to its loads and back through ground: the voltage lost, the copper's resistance, current density, via currents); signal (impedance and signals: each routed track as a transmission line, from a field solve of the copper it really runs over: impedance against its target, delay, loss, a pair's differential impedance and skew, tracks that leave their reference plane, crosstalk between neighbours); heat (heat: the board's steady temperature in still air under what its parts shed (their powers from the inputs, else from what they draw and what regulators lose): the temperature under each part, the hot spots); pdn (supply impedance: each supply's impedance over frequency at its main load, from its capacitors (value, package, DC bias), the copper between each and the load, and the planes: peaks over the target impedance, rails without decoupling, capacitors too far from their pins); emc (emissions: how well each signal and its return make an antenna: each net's loop area and the field it makes per milliampere against CISPR 32 class B, fast nets that cross a gap in their reference plane or change reference at a via with no ground via near, crystals far from their chips); channel (channels: each fast net or pair (USB, Ethernet, HDMI, PCIe, MIPI and the like, or one given a rise time) end to end as cascaded lossy lines and vias: the loss through it and the reflection from it over frequency, the eye at its bit rate, and its Touchstone file (.s2p)); wave (wave: a pulse launched into the fastest net (one given a rise time first) and followed through the board's own copper by Maxwell's equations in time: a film of the wave running the track, coming back from open ends and getting into what lies beside it, with the voltage at each pad over time; for seeing where a signal goes, not for impedance numbers); magnetic (magnetic field: the magnetic field of the supply currents (each rail to its loads and back through ground) a millimetre over each face, as a near-field probe would map it, the field over each part, and the field's lines round the copper in 3D; for steady and slowly changing currents (what a compass or a Hall sensor on the board reads), not for fast edges). Answers with each analysis's reading in a sentence, its findings with their places (mm) and the parts, pads and nets they are about, the numbers in tables, and what the reading rests on. What the copper is (a path's resistance) is always exact; what a scenario makes of it (volts lost, heat) follows currents: where the board cannot say them they are assumed and listed, and you make them real by writing .pcbkit/analysis.yaml (YAML: rails: { "+3V3": { voltage: 3.3, sources: [U2.5], loads: { U1: 0.15, U3.4: 0.02 }, current: 0.4, tolerance: 0.03 } }, parts: { U2: { power: 0.4 } }, ambient: 25), then calling this again. Run it after routing, and after every change to supply copper.

bash

ChatGPT
Runs one bash command in the project's sandbox, in the folder of the project's files (/project), and returns what it printed and its exit code. The sandbox is a Linux of the project's own on PCBKit's servers. It reaches the internet through a proxy that is already set (public https and http addresses only: curl, git and pip work as usual). Installed: KiCad 10 (kicad-cli, Python's pcbnew, its symbol and footprint libraries in /usr/share/kicad), Python 3 with the usual numeric, plotting, PDF and KiCad-file libraries, ngspice, node, git, jq, ripgrep, pdftotext, rsvg-convert (the skill's reference/kicad-tools.md lists it all). Files outside the project (/tmp, your scripts) stay while you work. Files written in the project are checked by PCBKit and redrawn for the person at once.

board

ChatGPT
The built board: read its objects (get, list), change one thing without rewriting text (move, set, connect, …), measure, the schematic; and show it to the person (camera, highlight, select, look: 2D/3D, layers, theme; overlay, tour, snapshot). Example: board { op: "camera", why: "The USB connector", ids: ["comp:J1"] }. Ops: list { … }; get { ids }; snapshot { … }; measure { ids }; move { id, … }; pin { … }; connect { id, net, … }; disconnect { id, … }; add { id, part, … }; remove { id, … }; rename { id, to, … }; set { field, id, value, … }; view {}; select { ids, … }; highlight { … }; camera { … }; look { … }; models { … }; overlay { … }; tour { … }; schematic { … }

board.library

ChatGPT
The person's boards: the signed-in person's projects, most recent first.

board.open

ChatGPT
Open the board for the person, once per conversation, right after the first design is written: it opens beside the conversation and follows every later change by itself, theirs too (they can pan, turn it to 3D, move parts and route there); what they select comes to you as context. Do not call it again for the same board: the board tool acts on the open one. You get its size, status and counts.

board.panel

ChatGPT
The board beside the conversation: the project the agent works on, drawn as it changes.

board_ticket

ChatGPT
The board's card asks for its permission to follow a project (not for the model).

check

ChatGPT
Checks the project: the syntax of its KiCad files (or of one), with line and column, and, where KiCad can run, KiCad's own checks: the electrical rules of its schematics (pins that fight, inputs nothing drives, power nobody supplies), the design rules of its boards (clearances, shorts, unconnected pads, the outline), with positions, and whether each board and its schematic connect the same pads. Files you write are checked for syntax anyway; call this when a step is done and before you say the board is ready.

design

ChatGPT
The board's source and its build: write and edit .pcbkit/design.pcbkit and its files (build: true builds in the same call), then run (place, route, fill), check, plan/diagnose a connection, clear copper. Example: design { op: "edit", why: "Add the status LED", path: ".pcbkit/design.pcbkit", edits: [{ find, replace }], build: true }. Ops: list { … }; read { path, … }; write { path, text, … }; edit { edits, path, … }; rename { from, to, … }; delete { path, … }; search { query, … }; format { … }; check { … }; plan { … }; diagnose { … }; clear { … }; run { … }

device

ChatGPT
Runs the board as the device it is, on PCBKit's bench: each processor executes the image its program's folder builds (the file that is flashed onto the made board, unchanged), wired to the board's parts as its nets wire them: displays, LEDs, buttons, sensors, servos, memories. The run is on the device's own clock, the same every time, faster than real time where it can be. Answers with what the consoles printed, what each part shows at the end, each step's outcome, and the screen's picture. A processor's program is the folder firmware (firmware/<reference> where the board has several processors), a project of its own build system (PlatformIO, Arduino, ESP-IDF, the Pico SDK, Zephyr, Cargo, make, or plain C for an AVR), or an image file; build builds it first. steps work the device and check it, in order: { wait: 0.5 } (seconds), { set: { SW1: 1 } } (a control: a button 1 or 0, a knob 0…1, a sensor's quantity), { press: SW1 }, { type: "status\n" } (into the console), { until: { console: "ready", within: 2 } }, { expect: { console: "T=23", D1: on, DS1: { lit: [0.01, 1] } } }, { shot: "screen.png" }. With plan it only says what the board is as a device: which parts it recognised, how each is wired, and what it leaves out; what the board cannot say (a header that is a servo, a module under another name) goes into .pcbkit/device.yaml (processors: { U1: { model: esp32, firmware: fw } }, parts: { J3: { model: servo, ports: { signal: 1 } } }). Run it after writing firmware and after changing what the firmware's pins are wired to.

edit

ChatGPT
Replaces one exact, unique piece of a project's file (old with new), or creates the file when old is empty.

enclosure

ChatGPT
Builds and checks the device's enclosure: the printed parts, the bought hardware (screws, inserts, nuts) and how it all goes together, written by you as a build123d program in enclosure/enclosure.py beside the board, with PCBKit's pcbkit Python package (the board as a mechanical object, hardware by its standards, room that must stay empty, the steps of assembly). Read the kicad-boards skill's reference/enclosure.md before writing the program. This runs it and answers with every check, one line a fact with its numbers: parts inside each other or inside the board's parts, the smallest gaps, a plug that does not reach its socket, a button held down by its cap, a screw too short for its insert, a part that cannot be put in. A line starting FAIL is a defect: fix the program and build again. A build writes enclosure/out/ (each printed part as STEP and as STL turned the way it prints, a 3MF plate, the page's shapes), and the person sees the device in its enclosure on the board at once, with a slider through its assembly to every part laid flat. check: only check, write nothing. tell answers a question instead of building: board (the board as a mechanical object: its size, frame, mounting holes, every part's side, kind, place, height and courtyard, what stands at its edges), api (the pcbkit package's classes and functions with their arguments), hardware (the screws, inserts, nuts and washers there are; add a word to narrow it: hardware m3).

export

ChatGPT
The files a factory makes the board from, as one zip, made by KiCad's own exporter: Gerbers of every copper layer, both masks, pastes and silkscreens and the outline; the drill files (plated and non-plated holes apart, slots as slots); the placement list and the BOM in JLCPCB's columns (its part numbers from a field such as LCSC or JLCPCB Part #; parts marked DNP left out). JLCPCB and PCBWay take the zip as it is. Answers where the zip is (on a computer, fab/ in the project; on the site, a link to give the person), what it holds (copper layers, size, whether the outline is closed, holes by size, parts on each side, BOM lines) and what to fix before ordering. Before it: zones filled (the export refills stale ones), the factory's limits in the rules and check clean.

feedback

ChatGPT
Sends PCBKit's team what the person says about PCBKit: something broken, something missing, an idea, praise. Call it when the person gives feedback on PCBKit or asks you to pass something on, and when PCBKit itself kept them from what they wanted (a tool that failed again and again, a result that was wrong). Write it short, in their words where you can, with what they were doing; from: agent when it is your own observation. Only this text is sent, nothing else of the project. Tell the person it was sent.

find_parts

ChatGPT
Search PCBKit's parts library (about 7 million parts with KiCad symbols, footprints and 3D models) by part number, description or values: 'STM32F103C8', '10k 0402 resistor', 'buck converter 3A'. Returns the best matches with their id (maker/mpn), package, JLCPCB code and stock, and what each one's datasheet states where it was read (its supply range, what it takes, what it gives).

help

ChatGPT
Guides (help { topic: "quickstart" } starts a board), one op's whole input (help { command: "design.edit" }), the language's blocks, parts and functions, open boards to learn from. Reads only. Ops: guide { … }; search { … }; describe { ids, … }; examples { … }; example { id, … }

lab

ChatGPT
The firmware in the simulator: write the program with design, then run (build and start), drive inputs, go on in time (until, advance), look (state, frame). help { topic: "simulation" } first. Ops: configure { id, … }; prepare {}; api {}; render { … }; frame { id, … }; catalog { … }; sources { id }; install { compiler, id, image_sha256, processor, program, source_sha256 }; example { … }; simulate { steps, … }; load { … }; advance { picoseconds, … }; until { picoseconds, … }; environment { celsius, co2_ppm, humidity, … }; control { id, value }; gamepads { gamepads }; keys { keys }; parameters { updates }; touch { id, points }; input { bytes, id }; checkpoint { id }; resume { id, state }; state {}; close {}; open { … }; battery { state_of_charge }; playback { action, … }; run { … }; compile { files, … }

look

ChatGPT
A picture of the board as it is now, for you alone to look at (the person does not see it, and their view does not change: to show them something, write .pcbkit/view.yaml). From the top by default (every layer: front copper red, back copper blue, silkscreen, the outline): whether the parts sit where you meant, overlap, leave room, and how the tracks run. around or center zooms in on a part or a place (a large board says little as a whole). view: "3d" is the board as an object (its mask, bodies, labels), from the same angles as camera.3d of the view file; a negative pitch shows the back. Look after placing parts and after routing. Where the board has a built enclosure, the 3D picture shows the device in it: stage takes its assembly apart step by step (0 together, the last stage every part laid flat), to see inside and to see each part; -1 leaves the enclosure out.

nets

ChatGPT
What the board connects, read from its file: each net with its pads (GND: C1.2, U1.4), nets that reach only one pad, pads on no net, and the parts with their places. With part, that part's pins and the net on each. Write the connections you intend into DESIGN.md before you write a board, then compare with this pin by pin: the design rule check cannot know that a pin is on the wrong net.

new_project

ChatGPT
Makes a new project in the person's PCBKit account: KiCad's starting files (board.kicad_pro, board.kicad_pcb, board.kicad_sch), or with from a copy of a public GitHub repository (github.com/owner/repo, …/tree/<branch>). Returns its id and files.

order

ChatGPT
Puts the board on a factory's own order page, ready to order there: its files for the factory (as export makes them) uploaded to PCBWay, OSH Park, AISLER, NextPCB, which answer with the order page the board is on. JLCPCB takes no upload from another site: PCBKit has JLCPCB read the files (its pre-review) and price five boards, and the person uploads the zip on its quote page. Nothing is ordered or paid: give the person the link; ordering is theirs. Call it only when the person asks to order.

part

ChatGPT
One part of the library (its id from find_parts, e.g. 'microchip/ATTINY85-20SU'): what it is, its package, JLCPCB codes with stock and price, its datasheet and what that states (supply range and absolute maximum, working and peak current, rated output, dropout, thermal resistances, each with its page; its specification tables row by row; what it is and has; the parts to put around it; its ordering codes), its pins by number and name, and its KiCad footprint as text, ready to put on a board (add the reference, the position and each pad's net). symbol adds the KiCad symbol's text. save_part writes both into the project as files.

parts

ChatGPT
Components: search the registry and the open libraries (queries for several), put parts with their support circuits into the design (use), datasheets, a part from its datasheet, orderable parts (select), the BOM. Example: parts { op: "use", why: "The CO2 sensor", ids: ["SCD40"] }. Ops: search { … }; describe { ids, … }; use { ids, … }; sheet { … }; datasheet { … }; create { sheet, … }; export { id, … }; select { … }; alternatives { … }; bom { … }

project

ChatGPT
The project as a whole: summary, other boards, import, export (fabrication files, KiCad), share links, comments, ordering at a fab. Example: project { op: "export", why: "Gerbers for the fab", format: "fab" }. Ops: summary { … }; new { name, … }; import { format, … }; export { format, … }; list { … }; open { … }; delete { id }; fabrication { … }; shops {}; order { shop, … }; share { … }; sharing {}; unshare {}; comments { … }; comment { text, … }; reply { id, … }; uncomment { id }

projects

ChatGPT
The person's projects on PCBKit, the latest first: id, title, when it last changed.

route

ChatGPT
Routes the board with PCBKit's autorouter: draws the tracks and vias of every connection not made yet, by the board's own rules (net classes, clearances, layers), and writes them into the .kicad_pcb. Place the parts and set the rules first. all removes the existing tracks and vias and routes everything again; clear only removes them. Takes up to seconds (default 60); says what it could not connect and why. The person watches the copper being drawn on their board while it runs.

save_part

ChatGPT
Writes a library part's KiCad footprint and symbol into the project (its id from find_parts): the footprint as parts.pretty/<footprint>.kicad_mod, the symbol into parts.kicad_sym (added to it, or put in place of its older self), for scripts and KiCad to read.

schematic

ChatGPT
Draws the project's schematic from its description: runs scripts/design.py, the parts and the net of each pin written once with pcbkit.schematic (the kicad-boards skill's reference/schematic.md has its form), which writes the .kicad_sch the way a person draws one to be read: blocks in frames, two-pin parts wired to what they serve, supplies and grounds as power symbols, a name on each chip pin. Then KiCad's electrical rules are run on it where KiCad can run. Answers with what the description said (a wrong pin with the symbol's real pins), what the rules found, and a picture of the sheet for you alone: read it, and zoom with look { view: "schematic", around: "U1" }. Call it again after every change of the description. A schematic a person drew themselves is never drawn over.

show

ChatGPT
Shows a project's board to the person, live: PCBKit's editor in the conversation (or beside it), following every change of the files. Call it once, when there is a board to see. Without project it opens the board the person changed last.

view

ChatGPT
The person's view of the project in PCBKit. With no arguments: what they look at now (the board on show, the view, what they selected: what "this" means). With arguments: shows them that, at once, as they watch (the fields given change, the rest stays): another view or board, a selection to point at what you speak of, a camera, layers, a look, the board apart, a tour. Show each step when it is done (the kicad-boards skill's reference/view.md); never a view per write.

Capabilities

WritesInteractive

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/pcbkit"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/pcbkit)