Skip to content

Connect over MCP

MagicON AI runs its design engines as an MCP server (Model Context Protocol — the standard way an AI assistant calls outside tools). Connect your assistant once and it can design an RF module, solve a PCB stackup, and check the result, using the same engines as the website.

Address: https://api.pcbgenerator.com/mcp/

Sign-in: none. There is no account and no API key.

Questions, bugs or a missing part: email support@pcbgenerator.com. With no account, we have no way to reach you first, so please write to us.

If you would rather call plain HTTPS endpoints, see API reference for LLMs. The engines are the same on both.

Connect

Claude Code

claude mcp add --transport http magicon https://api.pcbgenerator.com/mcp/

Claude Desktop and other apps with a "custom connector" screen

Add a remote connector and paste the address above. Leave any sign-in fields empty.

Cursor and other clients that read an mcp.json file

{
  "mcpServers": {
    "magicon": {
      "url": "https://api.pcbgenerator.com/mcp/"
    }
  }
}

Your client must support the Streamable HTTP transport. Once connected, ask it to list the MagicON tools; you should see fourteen.

The fourteen tools

Tool What it does
design_rf_chain Designs a transmit chain from a frequency and output power, with real parts, a priced parts list and disclosures
design_rf_receiver Designs a superheterodyne receiver: frequency plan, noise, sensitivity, converter interface
design_tr_module Designs a shared-antenna transmit/receive front end and its safety budgets
run_link_budget Cascaded gain, noise figure and headroom for stages you supply
run_stackup_solver Solves a PCB stackup against impedance targets. Each single-ended trace also returns its loss in dB per mm (copper, board material, roughness; standard copper foil assumed). Give line_length_mm for the line's total loss in dB, and input_power_w as well for the watts it turns into heat
run_thermal_analysis Junction temperature and board heat, from the design in this session
run_pdn_analysis Power-delivery impedance, from the design and stackup in this session
run_compliance_analysis Standards checks on the solved stackup and the chain's output
run_ota_link One-way over-the-air link: path loss, received power, margin and maximum range, in free space
run_radar_performance Radar range equation and pulse limits: received power, SNR, maximum detection range, unambiguous range
run_planar_filter A planar (copper-on-PCB) low-pass or band-pass filter: line sections, footprint, simulated response; name the laminate and its Dk comes from the material catalog
design_patch_antenna A rectangular patch antenna, or a planar array of it: dimensions, resonance, bandwidth, gain and beamwidths; name the laminate and its Dk comes from the material catalog
run_glass_weave_analysis Which PCB glass-weave style keeps impedance variation inside your tolerance, ranked by cost; uses the design frequency from this session when you give none
check_grounding Checks a draft you wrote against the results computed in this session; computes nothing

Every tool is read-only: it reads the part catalog and computes. It changes nothing in any account. A call writes the session's own short-term memory, described below, which is gone when the connection ends. One exception: when the open-in-MagicON link is switched on, a successful design call (design_rf_chain, design_rf_receiver, design_tr_module) also saves a copy of the session's results, and the inputs each call was given, on our server for up to 7 days, so the link it returns can open them (see "Open the design in the web app" below).

What is different from the HTTPS routes

The session remembers. Over HTTPS every call stands alone. Over MCP, one connection remembers the results computed in it. So after a design you can call run_thermal_analysis, run_pdn_analysis and run_compliance_analysis with no figures re-sent; they use the design. Two limits:

  • Only computed results are remembered. A number you typed into an argument is not evidence for a later call.
  • It lasts one session. A new connection starts empty.

PDN and compliance need a solved board. design_rf_chain solves one for you and says so in an autoSolvedStackup field. After a receiver or T/R design, call run_stackup_solver yourself first.

Pass your user's own words. Every tool accepts an optional user_request: the person's request, verbatim. With it, the result is labelled grounding.mode: "user_stated". Without it, the label is caller_asserted, meaning the numbers were taken on the calling assistant's word. The figures the engines compute are the same either way; the label is about the inputs.

Field names and units differ per tool. One takes gigahertz, another hertz. Read each tool's own schema rather than copying a body from the HTTPS page.

A refusal is a result. If an input is missing, the tool answers with the error flag set and names what it needs. Treat it as a question for your user, not a crash.

Check before you publish. Before you hand over a report or a summary built from these figures, pass the draft to check_grounding. It lists every figure no engine here produced. A pass is a filter, not a proof: it does not check claims outside the shapes it knows.

Limits

  • 10 requests per minute per IP address. A full session (connect, list tools, design, solve, thermal, PDN, compliance) is about 8 requests, plus one for an app that first asks for a newer protocol version, so one chain fits in a minute. Over the limit you get HTTP 429 with a Retry-After header.
  • The limit counts web requests, not only tool calls. Connecting and listing tools count.
  • user_request is at most 4,000 characters: pass your user's latest message, not the whole conversation. A check_grounding draft is at most 100,000 characters; check a longer one in parts. Over either limit the call is refused, the error names the limit, and nothing is computed.
  • Some designs take several seconds. Wait for the answer; there is no job to poll.

Open the design in the web app

When the link is switched on (FF_MCP_HANDOFF; off by default), a successful design_rf_chain, design_rf_receiver or design_tr_module call returns two extra keys: openInMagicOnUrl and openInMagicOnNote. Give the link to your user. They sign in at pcbgenerator.com and land in the MagicON Agent chat with the same result cards, where they can export CAD files.

  • The link works for 7 days and for one account: the first account to open it keeps the design.
  • To make the link work we keep a copy of the session's results, and of the inputs each call was given, for up to 7 days. Once the link is opened our copy is dropped, because the design then lives in that account. A copy nobody opens is deleted after it expires, the next time a new link is created.
  • One link per connection: a later design in the same session updates the same link until it is opened.

What it will not do

  • It does not export CAD files (KiCad, ODB++, Gerber) itself. Those need a signed-in account in the web app; the link above is how a design gets there.
  • A slot no catalog part can fill comes back in needsPartFlags, never filled with an invented part.
  • Compliance results compare a design against published limits; they are not a certification.