MagicON vs. the "related" MCP servers on Glama (2026-10-06)¶
Glama page: https://glama.ai/mcp/connectors/io.github.magiccadai/magicon (fetched 2026-10-06; its "Related" sections list exactly the 8 below).
Source limits. Every row was checked against the project's own site, GitHub README or Glama tool list (sources at the bottom). Nothing was tested by calling their servers.
MagicON's 9 tools: design_rf_chain, design_rf_receiver, design_tr_module, run_link_budget, run_stackup_solver, run_thermal_analysis, run_pdn_analysis, run_compliance_analysis, check_grounding.
Each competitor in one line¶
| Server | What it really does | Overlap with MagicON | What it has that we don't |
|---|---|---|---|
| calc.engineer (hosted, no key, 88–89 calcs) | Simple formulas: link budget over distance (EIRP, free-space loss, margin), LoRa, PCB, solar; plus a SPICE simulator and PCB autorouter | Link budget, PCB calcs | Over-the-air link budget, LoRa, SPICE, autorouter, breadth |
| device-house | Words → device.json BoM, enclosure STL, parts quote/order, compliance labels (Japan 技適 / PSE / CE). Calls itself a "deterministic matcher prototype". Site does NOT mention PCB routing, firmware or RF |
BOM, compliance | Enclosure, ordering, Japanese/CE certification labels |
| Source Parts (official, 111 tools, OAuth/API key) | Part search, distributor prices, live stock, alternatives, BOM import from KiCad/Altium/Eagle/…, assembly checks, schematic review, controlled-impedance calc | BOM, part catalog, impedance | Live price/stock, buying, BOM import from EDA files, assembly/AOI |
| RFix | Simulates RF signals in a terrain-aware scene; exports IQ / SigMF datasets | None — it tests hardware, it does not design it | IQ datasets, RF scenes |
| mcp-ltspice-qucs (AGPL, local, 3 servers / 140 tools) | Filter synthesis + power-supply EMC with LTspice, Qucs-S, scikit-rf; Monte Carlo; Touchstone files. Picks real passive parts ("Q/SRF, bias, temperature, and tolerance"); emission prediction vs "CISPR 22 / 32 and FCC Part 15", plus "FCC / ETSI / 3GPP eval". No active RF parts or chain cascade mentioned | Filters (we PICK catalog filters; they DESIGN them), EMC, FCC/ETSI (theirs = emissions; ours = conducted power) | Circuit simulation, filter synthesis, S-parameter files, real passive parts |
| rf-agent (Apache, local) | Passive RF copper shapes (e.g. at 11.6 GHz) → HFSS solve → Optuna tuning → Altium. No real parts, no footprints | Line impedance/loss (rf_line_model), X-band |
3-D field (EM) solve, auto-tuning, Altium export. Needs Ansys licence |
| mcp-pcb-emcopilot (AGPL, 93 tools) | Reviews a FINISHED board (KiCad/ODB++/Gerber/IPC-2581/Altium): EMC, SI, PI, thermal, DFM → Word/HTML report. Has stackup templates (pcb_get_stackup_templates, pcb_render_stackup, per Glama); whether it solves a stackup: not verified |
Thermal, power integrity, stackup templates | Reads an existing layout; signal integrity; DFM; audit reports |
| rfauto (GPL, local, 106 tools) | Drives 16 solvers (HFSS, ADS, COMSOL, openEMS, ngspice, KiCad…), 53 device templates; rule "every physical number from a solver, never the LLM" | Same grounding promise as ours | EM/circuit solvers, device templates, optimisation |
Pricing (read 2026-10-06 from each project's own page; prices change — re-check before quoting)¶
| Server | Cost to the user | Source |
|---|---|---|
| MagicON (us) | Free, no sign-in, rate-limited | PRODUCT.md, backend/middleware.py:73 |
| calc.engineer | Free: "Free, instant, no login". Glama tags its MCP "Keyless". Paid plans: none shown. API-key terms: not verified (page needs a login) | calc.engineer, Glama |
| ProtoFlow | Free $0 forever, no card (full editor, basic AI, 5 Basic + 10 Pro AI messages/day) · Pro $19.99/month (7-day trial) · Max $39.99 · Ultra $199.99 · Enterprise custom; pay-as-you-go credits $1 per 10. Whether MCP/CLI is in the free plan: not stated | protoflow.ai/pricing (read in a browser; the page is JavaScript-only) |
| rftools-mcp | Free $0 (5 API calls/month) · Pro $9/month (100 calls) · API $19/month (10,000 calls). Whether MCP calls count against these limits: not verified | rftools.io/pricing |
| Source Parts | Hobbyist $9 · Developer $49 · Professional $199 /month · Enterprise custom; 5,000 free credits for 30 days. A key "requires an active subscription" | source.parts/pricing, /docs/api |
| device-house | No price published | device.house |
| RFix | No price published; "Book Demo" / evaluation request only | rfix.ai (rfix.ai/pricing returns 404) |
| mcp-ltspice-qucs | Free, open source (AGPL-3.0). Needs LTspice (free, closed source), Qucs-S (GPL), scikit-rf (BSD) | GitHub README |
| mcp-pcb-emcopilot | Free, open source (AGPL 3.0, per Glama). Paid version: none found. Its repo page and the eng-mcp-suite page both return 404 | Glama |
| lineforge | Free, open source (AGPL-3.0 per GitHub; its README text also says "GPLv3"). "Pre-alpha: not yet on PyPI" | GitHub README, GitHub API |
| rf-agent | Code free (Apache 2.0), but solving needs Ansys Electronics Desktop and board export needs Altium Designer — both paid licences (their prices: not checked) | GitHub README |
| rfauto | Code free (GPL 3.0); runs with open-source solvers. HFSS/ADS/COMSOL are optional and need "your own valid licenses" | GitHub README |
What it means for us: the only hosted competitors that publish a price, rftools-mcp and Source Parts, charge $9/month and up for meaningful use. calc.engineer is the one free, no-login hosted rival, like us. The open-source ones are free but run on the user's own machine (some need paid simulators).
Bonus — not on our Glama page but the closest rival found: rftools-mcp (rftools.io, 24 tools,
255 calculators per https://rftools.io/agents/ on 2026-10-06; an earlier read the same day said 203): simulate_rf_cascade (RF budget), simulate_radar_detection,
simulate_sat_link_budget, simulate_pdn_impedance, simulate_impedance_matching, filter Monte
Carlo, EMI, eye diagram, NEC-2 antenna. It overlaps more with us than any of the 8 above. Deep-dive
in rftools.io up close below.
Also checked 2026-10-06 — ProtoFlow (Windows desktop app + CLI/MCP): general AI PCB design — "AI generates the schematic with real parts" (JLCPCB, DigiKey, LCSC, Mouser), layout, autorouter, ngspice simulation, Gerber/KiCad/Altium export. Its homepage does not mention RF, link budget, noise figure, impedance or thermal. A competitor for the board-design half of our users, not for RF module design.
Also checked 2026-10-06 — lineforge (same author as
mcp-ltspice-qucs; local): transmission-line impedance for microstrip, stripline, CPWG,
differential pairs and any 2D cross-section drawn as a bitmap; its README claims ±2 % against
IPC-2141 and openEMS. Its README says 14 MCP tools; its server code defines 21
(src/lineforge/mcp_server/server.py, read 2026-10-06), including target_z0 (finds the trace
width for a target impedance), laminate_lookup (laminate by name with Dk by frequency; its
docstring's examples are FR4 prepreg, Isola 370HR, Megtron 6, RO4350B — the full list not checked) and rf_path_budget (return loss of pads + trace — not a link budget). It does
not design a stackup: it takes the layers above and below ONE trace and reduces them to one
equivalent dielectric (series_reduce; its GUI StackupEditor.tsx does the same). Choosing layer
count, materials and thicknesses for a whole board — what our run_stackup_solver does — is not in
its tool list. Found through the author's GitHub profile, not Glama
(rfingadam-repos-check-2026-10-06.md).
Not a rival — could work alongside us: drawio-engineering-mcp
(same author, AGPL, 10 tools). It draws RF block diagrams (create_rf_block_diagram, from JSON
blocks, with its own gain/noise-figure cascade) and PCB stackup cross-sections
(create_pcb_stackup) in draw.io. MagicON designs; it draws. Left out of the ranking below.
Closest-competitor re-check (2026-10-06): each of the 10 above was read on its own page for four things — picks real RF parts by performance, designs a whole transmit/receive chain, solves a full stackup, FCC/ETSI. None does the first three; rftools-mcp stays the closest (separate RF calculators, no parts, no stackup). lineforge, found later the same day, was checked the same way and does none of the first three either. Not a market survey: only these 11 were checked.
Ranking — closest first (2026-10-06)¶
Rule: count how many of our capabilities each overlaps — cascade/link budget, impedance/stackup, thermal, PDN, compliance, real parts/BOM, "numbers from an engine, not the LLM" — using only what the rows above verified; ties go to the one aimed at RF designers (our users). The count is a judgement over those rows, not a measurement.
| # | Competitor | Overlap | Why not closer |
|---|---|---|---|
| 1 | rftools-mcp | 6: cascade, impedance, basic thermal, PDN, "formulas not LLM", RF-focused | Calculators only; no parts, no stackup |
| 2 | mcp-ltspice-qucs | 4: real passive parts, FCC/ETSI emissions, real simulators, RF-focused | Filters only; no chain, no stackup |
| 3 | calc.engineer | 3–4: link budget + NF cascade, thermal, EIRP check (LoRa only) | Separate calculators; broad, not RF-only |
| 4 | rfauto | 3–4: same grounding promise, RF-focused, cascade how-to, optional thermal (Icepak) | EM solvers; no parts, no stackup |
| 5 | mcp-pcb-emcopilot | 3: thermal, PI, stackup templates | Reviews a finished board only |
| 6 | Source Parts | 2: parts/BOM, impedance calc | Sourcing, not design |
| 7 | rf-agent | 2: line impedance, RF-focused | Passive structures only; needs paid Ansys |
| 8 | ProtoFlow | 2: real parts, BOM ("set the stackup") | General PCB, not RF |
| 9 | device-house | 2: BOM, compliance labels | Enclosure and ordering |
| 10 | lineforge | 1: impedance (one line at a time, with a laminate list), RF-focused | No chain, no parts; does not design a stackup |
| 11 | RFix | 0 | Generates RF datasets; designs nothing |
rftools.io up close (2026-10-06)¶
Link budget calculator, head to head¶
Their page: https://rftools.io/calculators/rf/rf-link-budget/ . Ours: /app/ota-link-calculator
(engine backend/services/solver/ota_link.py, route POST /api/ota-link/compute) — NOT
/app/link-budget-calculator, which is a part-by-part cascade (their equivalent is the separate
"RF Cascade Budget Analyzer").
Their page shows only results, so the inputs were worked back from them: 30 dBm, 2 dBi TX, 2 dBi RX, 2.4 GHz, 1 km, 0.5 dB extra loss, sensitivity −90 dBm. Our route (FastAPI TestClient, worktree code) returned:
| Figure | rftools | MagicON |
|---|---|---|
| EIRP | 32 dBm | 32.0 dBm |
| Free-space path loss | 100.05201 dB | 100.052008 dB |
| Received power | −66.55201 dBm | −66.552008 dBm |
| Link margin | 23.44799 dB | 23.447992 dB |
| Max range | 14.87303 km | 14,873.03 m |
Same Friis maths, same answers.
- They have, we don't: separate boxes for TX/RX cable, rain, atmospheric and pointing loss (we take one "misc loss" — the maths is the same sum); a band-sharing (ISM coexistence) box; a jump to an ITU-R satellite link tool; worked examples and FAQ; shareable scenario URLs.
- We have, they don't: a fade-margin input with a closes / marginal / fails verdict (theirs only labels the margin "GOOD"); sensitivity derived from noise figure + bandwidth + required SNR; power in watts; the inverse (transmit power needed for a range); FCC/ETSI verdicts from our compliance engine; reuse of a designed chain's figures in the agent chat.
- Decision (owner, 2026-10-06): don't copy the extra input boxes — PRODUCT.md "Not doing until 3 Jan 2027", and one misc-loss box gives the same answer.
How they offer 255 calculators without bloating the AI's memory¶
One MCP server, 24 tools, not one tool per calculator (https://rftools.io/agents/, read
2026-10-06): 6 general calculator tools (list, search, describe, get input schema, run, solve
backwards), 13 simulation tools (one each) and 5 job tools (submit, status, result, …). The AI
searches, fetches ONE calculator's input schema, then runs it, so only the calculator in use
enters its memory. It runs locally through npx rftools-mcp; simulations run as metered jobs on
rftools.io.
For us: an MCP client loads our whole tool list every chat (backend/mcp_server/tools.py:14-19),
and our tools are large — the 8 measured 32,370 B (see section A below). Listing each tool directly
stays right while we have a handful. If the four tools in #176 trip
backend/tests/test_mcp_tool_list_size.py, their search → describe → run pattern is the fallback,
and a small change for us: mcp_tools() (tools.py:240-260) already generates every input schema
from the chat declarations in one loop. Noted on
#176.
Breadth is their product; a whole module is ours¶
rftools is a toolbox — the user designs and uses calculators one at a time. MagicON's promise (PRODUCT.md) is the design itself: one request → real catalog parts, signal levels, stackup, heat, power, CAD files, with no invented number. So we do NOT race them on calculator count.
CAD files for MCP users¶
Owner choice (2026-10-06): after an MCP design, give the user a link to sign in on the site and
download the CAD files there (keeps the sign-up step and the CAD-download count). Checked the same
day: not possible today — MCP saves nothing (backend/mcp_server/session.py:155, "no
server-side project is created"), and every design link needs a saved project owned by the
signed-in user (frontend/src/App.tsx:339-344). A smallest-design sketch (hand the MCP results to
a new Agent chat on sign-in) is on
#182; it is a new
feature, so it waits for the weekly review.
Overlaps (where a user could pick them instead of us)¶
- Cascade / link budget — rftools-mcp (cascade, satellite), calc.engineer (over-the-air).
- Impedance — Source Parts, rf-agent, rftools-mcp, lineforge (each a calculator; ours solves a whole stackup).
- PDN / thermal — rftools-mcp (PDN), mcp-pcb-emcopilot (on a finished layout).
- BOM / parts — Source Parts, device-house (they source and buy; we pick for RF performance).
- Compliance — device-house (Japanese/PSE/CE labels; ours is FCC/ETSI limits), mcp-ltspice-qucs (FCC Part 15 / CISPR emissions, FCC/ETSI/3GPP eval).
- "Numbers come from an engine, not the LLM" — rfauto states the same promise.
Only MagicON (no one in this list claims it)¶
- Designs a whole transmit chain, receiver or T/R module from REAL catalog parts.
- Solves a full PCB stackup.
- FCC/ETSI conducted-power compliance of a designed chain (mcp-ltspice-qucs checks FCC/ETSI too, but for emissions, not the chain's output power).
check_grounding— checks a written report against the engine's own results.
Missing from MagicON¶
A. Already BUILT, just not on MCP (checked 2026-10-06)¶
The MCP server exposes only TIER1_TOOL_NAMES (backend/mcp_server/tools.py:60-69) plus
check_grounding. These agent tools exist in backend/tools/ and are classified SHARED_ENGINE
in backend/tools/_parity.py, i.e. backed by the same engine as a public route — but MCP users
cannot call them:
| Built tool | Closes the gap vs. | _parity.py line |
|---|---|---|
run_ota_link — over-the-air link: tx power, antenna gains, frequency, distanceM, fade margin, sensitivity |
calc.engineer, rftools-mcp | 43 |
run_radar_performance |
rftools-mcp (simulate_radar_detection) |
40 |
run_planar_filter |
mcp-ltspice-qucs, rftools-mcp (filter design) | 39 |
design_patch_antenna |
rftools-mcp (antenna) | 77 |
generate_export (KiCad/ODB++/ADS/Gerber/…) |
rf-agent (Altium), rfauto (KiCad) | 64 |
export_bom (csv/excel/json) |
Source Parts, device-house | 37 |
Decision (owner, 2026-10-06): add the four engine tools (run_ota_link,
run_radar_performance, run_planar_filter, design_patch_antenna) to public MCP, after the
N1 /mcp risk review — tracked in
#176. This needs the
36,000 B schema ceiling raised (backend/tests/test_mcp_tool_list_size.py:25; the 8 tools were
32,370 B and the four add 10,803 B, measured 2026-10-06), and each tool checked for refusing
invented inputs first. generate_export stays off public MCP (CAD download needs sign-in);
export_bom is skipped (design results already carry the BOM).
Our run_link_budget is a part-by-part cascade only — its declaration
(backend/tools/run_link_budget_parts/declaration.py) has no distance, antenna or margin input.
Whether each built tool is safe to expose without sign-in (as Tier 1 is): not verified.
B. Not built at all¶
Ranked by how close it is to our users (RF module designers):
- Live price / stock / alternatives — Source Parts, via
get_part_pricing,check_availabilityandfind_alternatives. Paid: Hobbyist $9/month, Developer $49/month, Professional $199/month, Enterprise custom yearly — all include API/MCP. New accounts get "5,000 free credits — no card required", which expire after 30 days. Their API docs say a key "requires an active subscription"; whether the free credits alone get a key: not verified. Which distributors the prices come from: not stated. (Read 2026-10-06 from source.parts/pricing and source.parts/docs/api.) - Circuit simulation, S-parameter files, matching networks — mcp-ltspice-qucs, rftools-mcp.
- Review of an existing layout (EMC, signal integrity, DFM) — mcp-pcb-emcopilot.
- EM (3-D field) simulation — rf-agent, rfauto.
- Out of scope for us: enclosure (device-house), IQ datasets (RFix), solar/homelab calcs.
Sources¶
- Glama MagicON page: https://glama.ai/mcp/connectors/io.github.magiccadai/magicon
- calc.engineer: https://calc.engineer , https://www.mcpbundles.com/skills/calc-mcp-4338305c36
- device-house: https://device.house
- Source Parts: https://glama.ai/mcp/servers/irf64n88ez , https://github.com/SourceParts/parts-mcp , https://source.parts/pricing , https://source.parts/docs/api
- RFix: https://rfix.ai
- mcp-ltspice-qucs: https://github.com/RFingAdam/mcp-ltspice-qucs , https://glama.ai/mcp/servers/sj7tclyjrl
- rf-agent: https://github.com/tisn1678065900-dot/rf-agent
- mcp-pcb-emcopilot: Glama (below). Glama links https://github.com/RFingAdam/mcp-pcb-emcopilot,
which returned 404 on 2026-10-06; https://github.com/RFingAdam/eng-mcp-suite returned 404 later
the same day (
gh api repos/RFingAdam/eng-mcp-suite/readme). The author's profile says his "PCB EMC design-review tooling stay private". - lineforge: https://github.com/RFingAdam/lineforge (README, GitHub API, and the code files
src/lineforge/mcp_server/server.py,examples/06_dielectric_stack.py,frontend/components/StackupEditor.tsx, read 2026-10-06) - drawio-engineering-mcp: https://github.com/RFingAdam/drawio-engineering-mcp (README, read 2026-10-06)
- rfauto: https://github.com/geer1895/rfauto — no website (GitHub homepage field empty);
created 2026-09-21, last push 2026-09-26, 0 stars (GitHub API, read 2026-10-06).
Tutorial: getting-started.md. How-tos: cascade-budget-and-spur.md
(overlaps our
run_link_budget), use-calculators.md, run-openems-smoke.md, read-verdict-gates.md. Examples: recipes/ (Wilkinson divider, branchline coupler, patch antenna) and matching skills/. Runs locally:pip install -e ".[dev,mcp]", MCP serverpython -m rfauto.mcp_server;--adapter fakeruns without a real solver. - rftools-mcp: https://glama.ai/mcp/servers/i1s18tmucp , https://rftools.io/pricing , https://github.com/antonpogrebenko-public/rftools-mcp (tool list re-read 2026-10-06), https://rftools.io/agents/ (24 tools / 255 calculators, read 2026-10-06), https://rftools.io/calculators/rf/rf-link-budget/ (head-to-head figures, pasted by the owner 2026-10-06)
- ProtoFlow: https://www.protoflow.ai , https://www.protoflow.ai/pricing
- mcp-pcb-emcopilot stackup tools: https://glama.ai/mcp/servers?query=mcp-pcb-emcopilot