PCB Copilot 开源：用自然语言生成并自动布线 2 层 PCB

PCB Copilot (CircuitPilot)

An AI copilot for electronics design: describe a circuit in plain language and it picks real parts from the JLCPCB/LCSC database, draws the schematic, runs ERC, then places and autoroutes a 2-layer PCB you can export as Gerbers. Use Claude, any OpenAI-compatible model or a local model, from the browser, your phone, or Claude Code via MCP.

See it in action

From one prompt to a routed board and a 3D-printed case — the copilot (Gemini Flash Lite) designs an ESP32 board from "create PCB for ESP": real JLCPCB parts, schematic, placement, rip-up autorouting (21/21 nets, DRC 0 errors), GND pours, then a fitted enclosure and a Whoop-style wristband pod (sped up 5×).

▶ Watch the full-speed video (MP4)

AI copilot designing a circuit (local Qwen 27B model, real tool calls, sped up)

The result, a fully routed board with a BOM and the design calculations, from a one-sentence prompt:

Generate & route the PCB	Search 600k+ real parts

Create symbols & footprints	Real footprints from the database

PCB editor — layers panel, PCB tools, hand routing with T/B layer switching (vias are added automatically)

Layers panel (show / hide / colour / active layer)	Hand-routed tracks + vias

3D board view — PCB toolbar ◈ 3D / ▦ 2D: solder mask, copper, ENIG/HASL pads, silkscreen on both sides and 3D part models (Top / Bottom / Iso, mask colour, pad finish)

3D-printable enclosure fitted to the board — STL + parametric OpenSCAD, editable by hand or by the AI

Inside (X-ray, lid lifted)	Closed

Design rules (JLCPCB defaults)	Autorouted 2-layer PCB

Projects	Project knowledge

Features

• Model picker — Claude (Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 4.5) or any OpenAI-compatible endpoint (OpenAI, Gemini, Grok, OpenRouter, Ollama, Ollama Cloud (via the server proxy), LM Studio, llama.cpp, vLLM / ExLlama / TabbyAPI, local servers); the context window is detected from the server.
• Three copilot modes — Agent edits the design with tools, Ask is read-only review and Q&A, Plan writes a BOM + netlist plan you approve with Execute plan.
• Every palette part is a real JLCPCB part — the schematic keeps clean symbols while the footprint and pinout come from a specific LCSC part (Basic parts where possible, LEDs by colour); ⇄ JLCPCB parts converts older designs and Export → BOM for JLCPCB assembly matches part numbers for every value.
• Real component database — JLCPCB/LCSC search with stock and price; exact pinouts and real footprints for every part, cached locally.
• Part editor — create or modify symbols and footprints (generators for SOIC/TSSOP/QFN/DIP/SOT…, draggable pads); saved to My Library.
• Projects — saved on the server with autosave; same projects on PC and phone.
• Chat attachments — 📎 attach photos, PDFs (datasheets), Word or any text file; paste or drag & drop too. Claude reads PDFs natively, other models get the extracted text; images go to vision models.
• Chat controls — 🌐 Web search toggle (on by default), 📁 folder for project docs, a context meter (used / window, % left), 🗜 Compress to summarise the chat, and automatic compression at 80% full.
• Project knowledge — point a project at a folder of docs, guides and datasheets (md/txt/pdf/docx) the AI follows.
• Checkpoints — every Agent message snapshots the design; restore with one click. Full undo/redo.
• Schematic editor — built-in parts plus database/custom parts, power symbols, click pin-to-pin wiring, drag, rotate (R), auto-layout.
• Professional schematic sheets — an A-series drawing frame with zone markers and a title block (title, company/author, document, sheet n of m, date, revision, size) filled from the Documentation fields; toggle it with the frame checkbox. Multi-page schematics: add sheets with ＋ in the sheet bar (double-click a tab to rename it), move parts between sheets from Properties, and nets that continue on another sheet are drawn as net labels and connected by name. The copilot can use sheets too (add_sheet, move_to_sheet, sheet in add_components).
• Readable spacing enforced — after every copilot edit the layout is spaced out so that parts and their net labels never overlap, no matter where the model put them.
• PCB — rule-driven 2-layer autorouter (Web Worker) with vias and neck-down, ratsnest, draggable footprints; routed tracks are straightened into clean 0°/45°/90° runs with a clearance safety margin, so they pass DRC.
• Routing that keeps trying — negotiated rip-up and reroute: when a net is stuck, the router finds the nets in its way, rips them up, routes the stuck net and re-routes the others, learning which corridors are contested (history cost), with restarts — for up to the Autorouter effort time (Rules, default 90 s), stopping as soon as everything is routed. Progress shows the nets still unrouted; Stop keeps the best result so far. No vias on SMD pins (via-in-pad only as a flagged last resort).
• Placement — Auto-place ▾ → Quick place: annealing that pulls connected parts together (2-pin links like decoupling caps hardest), keeps connectors (USB, headers, jacks) on the board edges and the biggest IC in the centre, runs several tries and keeps the best; with Board size empty it finds the minimum-area board (tries three board shapes, shrinks width and height while the placement stays legal) — e.g. 555 example 1124 → ~340 mm². ✦ AI place asks the model once for a floor plan (JSON mode, compact parts + nets list), then legalises, polishes and routes it — works with local models too.
• ✨ Optimize ▾ — moves parts (local re-arrangement around stuck nets and fresh global arrangements) and re-routes until every net is connected; …and make the board as small as possible then shrinks the outline step by step while everything still routes (e.g. 45×26 → 20.5×11.8 mm on the 555 example).
• Copper pours, arcs, bottom-side parts, curved boards — GND (or any net) pours with clearance cut-outs; arc tracks; footprints on the bottom side (mirrored, bottom copper/silk/paste); rounded, round/elliptical or custom board outlines.
• 3D board view — switch the PCB editor between 2D and a 3D render of the manufactured board (both sides, parts, mask colour, pad finish).
• Enclosure — a third tab builds a 3D-printable case around the PCB (follows the board outline, height from the tallest part, screw standoffs on PCB mounting holes, automatic openings for USB/jacks and holes above LEDs/buttons, snap-fit lid with vents); exports STL (base + lid) and parametric OpenSCAD.
• Placement optimizer — moves / rotates / swaps parts and re-routes until every net is connected (also available to the AI).
• Gerber export with DRC check — problems pop up with Fix on board / Re-route / Optimize / Download anyway.
• PCB editor — Layers panel (show/hide, colour, active layer, dim inactive), PCB Tools (Select, Track W, Via V, Measure M), interactive 45°/90°/any-angle routing with T/B layer switching and automatic vias, live clearance check, track/via properties, segment delete; the autorouter keeps hand-routed tracks.
• Design rules & DRC — JLCPCB 2-layer defaults, editable per project (trace/power widths, per-net widths, clearance, vias, edge clearance, layers); exact-geometry DRC with markers on the board.
• Exports — Gerber + Excellon drill (.zip), BOM (.csv), netlist (.net), schematic and PCB SVG, project JSON.
• One-click ordering — Order at JLCPCB ↗ (PCB toolbar) runs DRC, matches LCSC parts, saves the Gerber zip plus the assembly BOM and pick-and-place (CPL) files, and opens the JLCPCB quote page: drop the zip on Add gerber file, and for assembly upload the two .csv files. Order 3D print ↗ (Enclosure toolbar) builds high-resolution STLs and opens the JLC3DP quote page. (JLCPCB has no public upload link, so you drag the downloaded files in yourself.)
• Internet access for the AI — web_search and web_fetch let any model (Claude, Gemini, local Qwen …) look up datasheets, application notes, prices and anything else, reading web pages and PDF datasheets; private / local addresses are blocked. Toggle in ⚙ Settings (DuckDuckGo by default, optional Brave Search key).
• Light / dark theme — header button cycles 🖥 System → ☀ Light → 🌙 Dark (remembered per browser; the PCB canvas stays black for layer contrast).
• Automation — MCP server for Claude Code / Claude Desktop / Cursor, plus a REST + OpenAPI interface.

Run

No build step and no dependencies. Start the bundled server (static files + a proxy for local model servers):

python server.py 5173

On Windows you can simply double-click start.bat (starts the server, shows the LAN address, optionally opens a public Cloudflare link). Open http://localhost:5173 (or http://<your-PC-IP>:5173 from another device on your LAN), then open ⚙ Settings and add an API key.

API keys are stored in your browser's localStorage and sent directly from the page to the provider you choose — fine for personal/local use, but don't host it publicly with keys baked in.

Project layout

Limitations

• Palette parts (resistor, capacitor, LED, diodes, transistors, MOSFETs, regulator, op-amp, crystal, fuse, inductor, potentiometer, buzzer) are backed by real JLCPCB parts — their footprints and pinouts come from the part library and pins are matched by name, so e.g. the AMS1117's IN/OUT/tab and each LED's cathode land on the right pads. Pin headers / generic connectors and the push button keep standard generated footprints (a 4-pin tact switch's internal pairs are not documented in the library); if you pick a generated footprint from the Footprint menu, verify its pin order against your part's datasheet.
• The router works on a grid; very dense boards can still leave a net unrouted within the time budget — run ✨ Optimize, add a GND pour, or give it a bigger board.
• Touch editing (drag/pinch) on phones is not implemented yet.

Local models (llama.cpp, TabbyAPI, LM Studio, Ollama…)

In ⚙ Settings → OpenAI-compatible, enter the server URL (e.g. http://localhost:8080/v1 or click the Local :8080 preset). The model list is fetched automatically from /v1/models and appears in the model picker. The model must support OpenAI-style tool calling for Agent mode.

Requests to localhost servers are routed through server.py (/llm-proxy/<port>/...), so local models work even when they only listen on 127.0.0.1 or don't send CORS headers — including from a phone on your LAN.

Public URL (Cloudflare tunnel)

python server.py 5173 --allow-ports 8080 --password YOUR_PASSWORD
cloudflared tunnel --url http://localhost:5173

Always set a password when exposing the app: the LLM proxy gives access to your local model. The proxy only forwards to ports listed in --allow-ports (default 8080).

Component database (JLCPCB / LCSC)

Type a part number in the Parts search box (e.g. ESP32-C3, AMS1117, CH340C, USB-C) to search the JLCPCB/LCSC catalogue (stock, price, Basic/Extended). Click a result to place it: the exact pinout and real PCB footprint are loaded from the part library (see Data sources below).

The AI copilot has the same database through the search_parts and get_part tools, so you can ask for e.g. "ESP32-C3 board with USB-C, AMS1117 regulator and a status LED" and it will pick real in-stock parts.

Everything fetched is cached in a local SQLite database (parts.db), so parts you've used keep working offline. Part definitions are also saved inside each design file.

Projects

Projects are stored on the server (projects.db, SQLite) and saved automatically — the status next to the project name shows ✓ Saved. Use ▤ Projects to open, duplicate, rename, delete or import projects, ＋ New to start one, and Save as… (Ctrl+Shift+S) to save the current design under a new name and continue in the copy. The same projects appear on every device that opens the app. Export → Project file (.json) downloads a portable copy.

Part editor (custom symbols & footprints)

• ＋ New part (Parts panel) opens the editor: pins (number, name, side L/R/T/B, bulk edit), live symbol preview, and a footprint editor with generators (0805, SOT-23, SOT-223, SOIC-n, TSSOP-n, QFN-n(-EP), DIP-n, pin headers…), draggable pads (0.05 mm snap) and per-pad size/shape/drill.
• Select any placed part → ✎ Edit symbol & footprint to fix a database part, or ✎ Make editable part to turn a built-in part into a custom one.
• Saved parts go to My Library (shared across projects); every placed instance updates when you edit a part.
• The AI can do the same with the create_part / update_part tools.

Project knowledge folder

Click 📚 Knowledge in the copilot and enter a folder on the PC running the server. Design notes, requirements, coding/naming rules and datasheets (.md .txt .pdf .docx .csv .json, source code…) are given to the AI: small documents go straight into its context, the rest it searches and reads with knowledge_search / knowledge_read. Try it with examples/knowledge.

Only document-type files inside the chosen folder are read (no .. escapes, hidden folders and .git/node_modules are skipped). Anyone who can log in to the app can point it at a folder on the server PC, so keep the password private.

Control from Claude Code (MCP) and other tools

mcp/circuitpilot-mcp.mjs exposes all 29 design tools — projects, parts database, schematic editing, ERC, custom parts, knowledge, PCB generation, Gerber export — through the Model Context Protocol. It runs the same engine as the browser app and talks to the running server.py, so every change shows up live in the browser.

Claude Code — this repo ships a .mcp.json, so just open the folder in Claude Code (with server.py running) and approve the circuitpilot server. Or add it globally:

claude mcp add circuitpilot -e CP_URL=http://localhost:5173 -- node /path/to/PCB_Copilot/mcp/circuitpilot-mcp.mjs

Then ask e.g. "Using circuitpilot, create a project 'ESP32 sensor board' with an ESP32-C3-MINI-1, AMS1117 and USB-C, then generate the PCB and export Gerbers to ./fab".

The password is read from access-password.txt (or set CP_PASSWORD). Other MCP clients (Claude Desktop, Cursor, VS Code…) use the same command.

REST / OpenAPI for anything else (scripts, n8n, OpenAI function calling…):

node mcp/circuitpilot-mcp.mjs --http 5174
curl -H "Authorization: Bearer <password>" http://127.0.0.1:5174/tools
curl -H "Authorization: Bearer <password>" -X POST http://127.0.0.1:5174/tools/search_parts -d '{"query":"CH340C"}'

GET /openapi.json returns an OpenAPI 3.1 spec of every tool. Add "project": "<id or name>" to any call to switch project. The REST server listens on 127.0.0.1 only (add --public to expose it).

Design rules (JLCPCB defaults) and DRC

PCB → ⚙ Rules edits the project's design rules. The autorouter follows them and DRC checks the finished board against them.

• Presets: JLCPCB recommended, JLCPCB minimum (5/5 mil), JLCPCB power/robust, Home etching / CNC (1 layer) — then tweak any value.
• Per-net widths (e.g. +5V 0.8 mm, MOTOR 1.2 mm); power and ground nets automatically use the power width.
• Neck-down: when a wide trace can't reach a fine-pitch pad, the router narrows it (power width → trace width → fab minimum) and reports which nets were necked down.
• Clearance is computed against the real pad shapes, so traces escape fine-pitch QFN/USB-C pads at JLCPCB clearances. Vias are allowed inside a net's own large pads (e.g. module ground pads).
• DRC uses exact geometry: shorts and clearance, trace width, via drill and annular ring, hole-to-hole spacing, copper-to-edge, unrouted nets, and rules set below the fab minimums. Click a violation to zoom to it.
• The AI and MCP/REST clients get get_design_rules, set_design_rules and run_drc; generate_pcb reports the DRC result.

Values follow JLCPCB's published capabilities; check jlcpcb.com/capabilities for the latest before ordering.

PCB editor

Live feedback: the coordinate bar shows X/Y, layer, width, net, and warns when the track being drawn violates the clearance rule; vias placed while routing are checked too. Route (autorouter) keeps every hand-drawn track and re-routes the rest with rip-up; the ratsnest and the “routed” count follow the real copper.

Connectors on the board edge

Board size is kept: once a board exists (or you type a size in Board W×H), Auto-place and Generate PCB fit the parts inside the existing outline — rectangle, rounded, round or custom — scaling the schematic arrangement to the board, keeping parts inside the edge clearance, rotating long parts and tightening spacing when crowded. The board is never enlarged on its own: if the parts cannot fit you get a message with how much of the board they need. Clear the Board W×H boxes to size the board to the parts instead. The ✨ Optimizer also keeps the board size.

Generate PCB puts connectors on the nearest board edge automatically: USB, DC jacks, RF and card connectors are rotated so the opening faces outward, flush with the edge (so a cable can plug in); pin headers and terminals sit just inside the edge. To choose the edge yourself, select the footprint on the PCB and click ⇤ Left / ⤒ Top / ⤓ Bottom / Right ⇥ in Properties — or ask the AI ("put the USB connector on the bottom edge"), which uses the place_footprint tool. The choice is remembered for later re-placements; press Route afterwards to reconnect.

More PCB tools

Enclosure (3D print)

The Enclosure tab builds a printable case around the current PCB and previews it in 3D (drag to orbit, right-drag to pan, wheel to zoom; Explode, X-ray, Lid, PCB toggles).

• Fits the board: the cavity follows the board outline (rectangle, rounded, round or custom) plus a clearance gap; the height comes from the tallest part (estimated per package — override any part height).
• Board support: click ＋ Add M3 mounting holes (adds non-plated Ø3.2 mm holes to the PCB, kept clear of parts and copper, in the NPTH drill file) to get screw standoffs; without holes the board rests on corner supports. Standoffs rise automatically to clear parts on the bottom side.
• Openings: automatic for edge connectors (USB, DC jack…, at the right wall and height) and holes in the lid above LEDs and buttons; add your own rectangle / circle cutouts on any wall, the lid or the floor.
• Lid: snap-fit lip with an adjustable fit tolerance, optional vent slots.
• Export: STL ⤓ (base + lid; the lid is already oriented for printing), OpenSCAD ⤓ (parametric source of the same design), or All (.zip) with print notes.
• AI: "make the walls 3 mm, add a 6×4 mm cable slot on the right and more room above the board" → set_enclosure, add_enclosure_cutout, add_mounting_holes, get_enclosure; Claude Code can also export_enclosure straight to a folder.

Custom 3D designs (wearables, patches, organic cases)

Switch the Enclosure tab to Custom 3D for anything that is not a box: a Whoop-style wristband pod with a curved underside and strap lugs, an ECG chest patch with snap-electrode holes, clips, mounts, rounded or organic housings. Just describe it to the AI:

"Make a wristband pod like Whoop for this board: 22 mm strap, USB-C opening, as thin as possible" "ECG chest node with 3 snap-electrode holes 60 mm apart on the skin side and a window over the LED"

The AI writes a short 3D script (set_enclosure_script): rounded boxes, convex hulls, extrude / revolve, union / difference / intersection, transforms — positioned relative to the PCB, whose outline, part boxes, heights and edge connectors it gets as context. Every build returns a fit report (printed parts colliding with the board or components, script errors with line numbers), so the AI iterates until it is clean.

• 35 tested templates, all sized from your board: 10 wrist wearables (Whoop-style pod, round / square / hex / octagon watches with spring-bar lugs, capsules, slim bands, cuffs — concave wrist backs), 10 chest / ECG (3-lead oval, heart-rate strap pod, Holter 5-lead with belt clip, round and hex 3-electrode patches, adhesive patches with flange, lead-wire box, 4-electrode patch), 7 other body-worn (ankle, arm, headband, pendant, key fob, belt clip, badge) and 8 boxes. Every template is checked on real boards: the PCB and every part are inside, nothing collides, every printed part is watertight.
• Enclosure kit for the AI and for your own scripts: envelope() (board + every part), outlines that contain it (oval, circle, pill, hex, octagon, squircle), soft rounded bodies, wrist curves, strap lugs, snap-electrode holes, belt clips, loops, connector openings, LED / button windows, board posts, and a lid with a press-fit lip.
• </> Script opens the editor (Ctrl+Enter to build, templates: wristband pod, ECG patch, rounded box; ? shows the API).
• Builds run in a sandboxed Web Worker (no network access) and produce watertight meshes.
• Export: one STL per part (lids/covers flipped for printing), equivalent OpenSCAD source, and the script itself in the zip.

The geometry engine (CSG with watertight-mesh repair) is self-contained JavaScript, so it runs in the browser and in the MCP server; only the 3D preview loads three.js from cdnjs.

Documentation (product datasheet PDF)

The Documentation tab turns the design into a product datasheet — previewed live, exported with PDF ⤓:

• cover with title, tagline, 3D render and key specifications; description, features and applications (✦ Write with AI drafts them from the design; edit them in the side panel)
• main components and power rails, full schematic
• PCB: 3D renders of the top and bottom, copper layout, PCB / fabrication specifications (size, layers, track / space, vias, holes, routing, DRC / ERC)
• mechanical drawing with board dimensions, mounting holes and edge connectors; connector pinout tables
• enclosure renders (assembled and exploded) with dimensions; bill of materials with LCSC numbers; revision table

Enclosure STL ⤓ files are always rebuilt at high resolution (≈0.4 mm curve segments) so they can go straight to a 3D-printing service; the on-screen preview stays fast.

EasyEDA interchange

• Export → Schematic for EasyEDA (.json) writes the schematic as an EasyEDA Standard document (symbols, pins, net labels, LCSC part numbers). Open it in EasyEDA Standard with File → Open → EasyEDA Source, or in EasyEDA Pro with File → Import → EasyEDA (Standard).
• Projects → Import .json / EasyEDA PCB opens an EasyEDA Standard PCB (File → Export → EasyEDA Source in EasyEDA) as a new project: footprints become library parts (LCSC numbers kept), with placement (top/bottom, rotation), nets, tracks, vias, holes, copper areas and the board outline; a schematic is generated from the nets.

Data sources & licenses

CircuitPilot's design, code and UI are original work. It uses third-party data and libraries, credited here as their terms require:

• Component catalogue (search, stock, price, LCSC numbers): JLCPCB / LCSC.
• Part symbols & footprints for database parts: the JLCEDA/EasyEDA official library — https://easyeda.com · https://lceda.cn. Its terms require this source to be declared; parts are used here only to design boards to be made with these parts.
• three.js (MIT) for the 3D previews; the CSG algorithm in js/enclosure.js follows csg.js by Evan Wallace (MIT).
• Web search results come from DuckDuckGo (or Brave Search with your own key).