Bragproof

← Reports

rftools-mcp

Starts with no setup2.11.2npm

Installed, started with no arguments, no environment and no input, and listed its tools. Run 2026-11-16.

Needs to start: nothing
Returns a result when called with no setup: 2 of 2 tools tried
Contacts while installing and starting: nothing

25tools listed
0hosts contacted
0files written
0.2 sto start
95dependencies

Its tool definitions changed since version 2.10.1. If you approved the earlier ones, read them again.

What it contacted

Nothing besides the npm registry it was installed from. Watched from outside its sandbox while it was installed and started with no input. Its tools may still contact things when called.

Starting it

npx -y rftools-mcp@2.11.2

Installing a package runs its code. Use a sandbox for anything you have not read.

Calling its tools

2 tools that take no input and look read-only were called once with nothing. 2 returned a result.

list_calculatorsReturned a result under 0.1 s · 77,562 characters
list_simulation_toolsReturned a result under 0.1 s · 6,046 characters

During the calls it contacted nothing it had not already contacted.

Only tools whose names read like looking something up, with no required input, are tried, five at most. Tools that need input, and anything that sounds like it changes or sends something, are not called.

What its tools tell an agent

In the tool descriptions, nothing that talks about the user, other tools or private files, or uses hidden characters.

Found by simple pattern rules in each tool's description (up to 3,000 characters), quoted as written. Parameter descriptions are not scanned. A clean result is not a safety review.

Tools

list_calculators category
List the RF and electronics calculators on rftools.io, or those in one category.
Inputs: category, optional: one of rf, pcb, power, signal, antenna, general, motor, protocol, emc, thermal, sensor, unit-conversion, audio, iot. An unknown category is refused with this list.
Example: {"category":"pcb"}
Returns: A JSON array with each calculator's slug, title, category and description. search_calculators finds one by words instead of listing all 257.
search_calculators query, category, limit
Find the calculators that fit a task described in words, in English or in any of the languages rftools.io is published in.
Inputs: query, the words to match (required; English, de, es, fr, ja, ko, pt); category, optional: one of rf, pcb, power, signal, antenna, general, motor, protocol, emc, thermal, sensor, unit-conversion, audio, iot; limit, optional, 1 to 25 results (default 10).
Example: {"query":"trace impedance on FR4 microstrip","limit":5}
Returns: The matches, highest score first, each with slug, title, category, a one-line description, the page URL and its score, plus how many calculators matched in all. A search that matches nothing is reported as an error saying so, not as an empty list. Pass a slug to get_calculator_schema or run_calculation.
get_calculator_info slug
Describe one calculator: its inputs with units, defaults and bounds, its outputs, formula and keywords.
Inputs: slug, a calculator identifier from list_calculators or search_calculators.
Example: {"slug":"microstrip-impedance"}
Returns: The calculator's slug, title, category and description; its inputs (key, label, unit, defaultValue, min, max, tooltip); its outputs (key, label, unit, tooltip); the formula and keywords. get_calculator_schema returns the same inputs as a JSON Schema.
get_calculator_schema slug
Give the exact input contract of one calculator as a JSON Schema, with its outputs, formula reference and page URL.
Inputs: slug, a calculator identifier. A misspelt one is refused, naming the closest identifiers.
Example: {"slug":"microstrip-impedance"}
Returns: inputSchema, a JSON Schema 2020-12 object whose properties are the input keys, each a number with its unit (x-unit), minimum, maximum, default and description; outputs (key, label, unit); formula (primary text, LaTeX where there is one, and the reference it comes from); and url.
run_calculation slug, inputs
Compute a calculator's outputs for given inputs, locally in this server, with no API key.
Inputs: slug, and inputs keyed by the calculator's input names in the units get_calculator_schema reports. An input left out takes its declared default and is listed in defaultedInputs; a key the calculator does not declare is not read and is named in a warning; a value outside the declared range is still computed, with a warning naming the range.
Example: {"slug":"microstrip-impedance","inputs":{"traceWidth":3,"substrateHeight":1.6,"dielectricConstant":4.3}}
Returns: slug; results, one per output with key, label, value and unit; webUrl; defaultedInputs; warnings and errors when there are any; and provenance: the formula source, assumptions, whether the inputs lie in the range the calculator is stated for, the inputs used and the engine version.
20 more tools
solve_calculation slug, inputs, solveFor, target, grid, range
Find the value of one calculator input that makes an output equal a target, such as the trace width that gives 50 Ω on microstrip-impedance.
Inputs: slug; inputs, the calculator's other inputs keyed by name in its units; solveFor, the input to solve; target {output, value}; grid, optional, a step to round the answer to; range [low, high], required when solveFor states no bound. get_calculator_schema states every input and output key, unit and bound.
Example: {"slug":"microstrip-impedance","inputs":{"substrateHeight":1.6,"dielectricConstant":4.2,"copperThickness":35},"solveFor":"traceWidth","target":{"output":"impedance","value":50}}
Returns: The solved value (rounded to the grid when one is given, with the unrounded value), reached, which is false when no value in the range meets the target and the nearest value found is returned instead, the number of evaluations, warnings, and the full calculator result at that value with its provenance.
Runs on rftools.io, not locally: it needs RFTOOLS_API_KEY and spends one metered call from the account's monthly allowance, like POST /calculate.
simulate_antenna_sim solveMode, freq, referenceImpedance, wires, feed, ground, conductor, optimize, freqStart, freqStop, freqPoints, sweepVariable, heightStart, heightStop, heightPoints, antennaType, groundType, randomSeed, waitSeconds, full
Solve your own wire antenna with the NEC-2 method of moments: dipoles, Yagis, verticals and loops, element by element.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Free lane: solveMode cannot be optimize without a paid key. Cross-parameter checks: sweep_stop_after_start. Time budget 1200 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"solveMode":"instant","freq":146000000}
Returns: Peak gain, front-to-back (one direction behind) and front-to-rear (worst of the rear half) ratios, beamwidths, feed impedance and VSWR (per frequency on a sweep, with the VSWR bandwidth), the azimuth and elevation patterns described as series, and for Optimize the recommended design and its Pareto front. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_emi_radiated standard, measDist, dmCurrent_mA, loopArea_cm2, cmCurrent_uA, cableLen_m, fClk_MHz, dutyCycle, tRise_ns, nTrials, randomSeed, waitSeconds, full
Estimate radiated emissions from PCB loops and cables using Paul's analytical DM/CM models.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Time budget 240 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"standard":"fcc_b","measDist":3,"dmCurrent_mA":5,"loopArea_cm2":0.5,"cmCurrent_uA":2,"cableLen_m":1,"fClk_MHz":480,"dutyCycle":50,"tRise_ns":0.5,"nTrials":100000} (the "USB 2.0 Trace Loop" preset)
Returns: Pass or fail against the chosen limit, the margin at the 5th, 50th and 95th percentiles, the strongest harmonics, and the emission spectrum and limit line described as series. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_eye_diagram dataRate, prbs, samplesPerUI, launchSwing, equalization, ctleDcGain, maskType, maskHalfHeight, maskWidth, samplingPhase, lossFrequency, inputFiles, inputPaths, waitSeconds, full
Upload a Touchstone (.s2p) file and generate a PRBS eye diagram.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Takes 1 to 1 .s2p/.s4p file(s) via inputFiles (inline) or inputPaths (local paths); the server uploads them. Uploading a file needs an API key; set RFTOOLS_API_KEY. Time budget 120 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"dataRate":10000000000,"prbs":"prbs15","samplesPerUI":64,"launchSwing":2000,"equalization":"none","maskType":"none","inputPaths":["/path/to/file.s2p"]}
Returns: Eye height (also as a share of the swing), width and jitter at the best or a stated sampling phase, any mask's pass and margin, any CTLE's gain, peaking and the eye before it, the file's details and loss at Nyquist, and the eye traces, impulse response and transfer function as series. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_fdtd_sparam structureType, substrateName, subEr, subH, subTanD, traceW, traceL, stubL, gapW, viaDia, viaAR, w2, freqCenter, freqSpan, solveMode, copperT, roughness, waitSeconds, full
Solve microstrip stubs, coupled-line filters, via transitions, and step discontinuities across a ladder of named solve modes — from a 2D cross-section in seconds to a fine 3D openEMS field solve.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Free lane: solveMode cannot be normal or fine without a paid key. Cross-parameter checks: sweep_span_within_center. Time budget 32400 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"structureType":"microstrip_open_stub","substrateName":"FR4","subEr":4.4,"subH":1.6,"subTanD":0.02,"traceW":3}
Returns: The solve mode and method actually used, S11 and S21 in dB and the Smith-chart traces described as series, the summary figures such as resonance, notch depth and input impedance, and flags for a degraded or physically invalid result. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_filter_monte_carlo filterType, bandType, order, freqCutoff, ripple, impedance, componentTolerance, toleranceDistribution, rippleSpec_db, rejectionSpec_db, monteCarloIterations, randomSeed, parts, passCriteria, yieldTarget, waitSeconds, full
Analyse how component tolerances affect your filter's passband ripple and stopband rejection.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Free lane: monteCarloIterations max 1000. Cross-parameter checks: filter_parts_ladder, filter_pass_criteria. Time budget 180 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"filterType":"butterworth","bandType":"lowpass","order":5,"freqCutoff":1000000000,"ripple":0.5,"impedance":50}
Returns: The yield and its 95% confidence interval against the ripple and rejection limits or the entered pass criteria and a target, failures and statistics per criterion with each part's share of the variance, failing trials, what-ifs on the same trials, and the envelope, sample trials and responses as series. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_impedance_field_solver solveMode, structureFamily, planes, layers, conductors, mask, copper, frequencies, designFrequency, solveFor, tolerances, distribution, samples, specification, randomSeed, stackup, waitSeconds, full
Solve a PCB cross-section with a 2-D field solver: microstrip, stripline, coplanar waveguide and differential pairs, with trapezoidal traces, plating, solder mask and mixed dielectrics.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Free lane: solveMode cannot be yield or stackup without a paid key. Time budget 300 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"solveMode":"solve","planes":"bottom","layers":[{"thickness":0.0002,"er":4.3,"tanD":0.02}],"conductors":[{"role":"signal","boundary":1,"x":-0.000175,"width":0.00035,"thickness":0.000035}],"frequencies":[1000000000,5000000000]} (the "50 Ω surface microstrip, FR-4, 1 oz" preset)
Returns: Per frequency, Z0 or a pair's whole mode set with effective permittivity, delay, L and C, loss with validity flags, the stated uncertainty and any width or spacing solved for; a yield adds the pass fraction with its 95 % interval, histograms with the limits, the extreme samples and the tolerance to tighten first. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_impedance_matching sourceR, sourceX, loadR, loadX, loadModel, freqStart, freqStop, designFreq, topology, maxQ, componentSeries, branchPreference, partModel, packageSize, inductorTechnology, capTolerance, indTolerance, yieldTrials, randomSeed, targetRL, sourceFileRole, inputFiles, inputPaths, waitSeconds, full
Synthesize L, Pi, T, or ladder matching networks for broadband impedance transformation.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Takes up to 2 .s2p/.s1p file(s) via inputFiles (inline) or inputPaths (local paths); the server uploads them. Uploading a file needs an API key; set RFTOOLS_API_KEY. Free lane: yieldTrials max 1000. Cross-parameter checks: sweep_stop_after_start, design_freq_in_band, load_model_fits_load, part_family_supported. Time budget 180 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"sourceR":50,"sourceX":0,"loadR":200,"loadX":0,"freqStart":800000000,"freqStop":1200000000}
Returns: The chosen topology and its snapped and ideal parts, the worst in-band return loss against the target, loaded Q, f0 return loss, VSWR, mismatch loss and RL ≥ 10 dB bandwidth, and S11 and Smith series; with real parts, each part's SRF, Q, ESR and the dissipation loss; with yieldTrials, the yield and its 95 % interval. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_magnetics_optimizer topology, Vin, Vout, Iout, fSw, dutyCycle, inductance_uH, iPeak_A, Tamb, Tmax, objectiveWeight, population, generations, randomSeed, waitSeconds, full
NSGA-II optimizer finds Pareto-optimal core and winding designs across 40 cores (E, ETD, PQ, RM and toroids) and 104 core/material combinations, with TDK and Ferroxcube ferrites and Micrometals iron powder.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Cross-parameter checks: converter_load_nonzero. Time budget 360 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"topology":"flyback_xfmr","Vin":48,"Vout":12,"Iout":3,"fSw":100000,"dutyCycle":0.45}
Returns: The best design (core, turns, air gap, wire gauges and flux densities), its losses, efficiency and temperature rise with a thermal pass or fail, and the Pareto front and evolution history described as series. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_pdn_impedance boardWidth_mm, boardLength_mm, dielectricEr, lossTangent, boardThickness_mm, portX_mm, portY_mm, portSize_mm, vrmBandwidth_hz, vrmDcr_mohm, boardInductance_nh, targetImpedance_mohm, freqMin_hz, freqMax_hz, maxCapCount, randomSeed, waitSeconds, full
Choose decoupling capacitors for a PCB power delivery network.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Cross-parameter checks: port_within_board, sweep_stop_after_start. Time budget 360 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"boardWidth_mm":85,"boardLength_mm":54,"dielectricEr":4.5,"lossTangent":0.02,"boardThickness_mm":1,"portX_mm":28.3,"portY_mm":18,"vrmBandwidth_hz":100000,"vrmDcr_mohm":5,"targetImpedance_mohm":15,"freqMin_hz":1000,"freqMax_hz":500000000,"maxCapCount":15} (the "Credit Card Size (85x54mm)" preset)
Returns: The chosen decoupling capacitors, the worst impedance in the decoupling band against the target with a pass or fail and any frequencies no budget can reach, the cavity resonances of the board, and the impedance curves described as series. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_radar_detection frequency_hz, peakPower_w, antGainTx_dbi, antGainRx_dbi, noiseFig_db, lossesTx_db, lossesRx_db, pulseWidth_s, nPulses, swerlingModel, pfa, targetRcs_dbsm, rangeMax_km, rainRate_mmhr, randomSeed, waitSeconds, full
Compute probability of detection (Pd) vs range for pulsed radar systems.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Cross-parameter checks: probability_in_open_unit_interval. Time budget 300 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"frequency_hz":3000000000,"peakPower_w":5000,"antGainTx_dbi":35,"antGainRx_dbi":35,"noiseFig_db":4,"pulseWidth_s":0.00001,"nPulses":20,"swerlingModel":"1","targetRcs_dbsm":5,"rangeMax_km":300} (the "Surveillance Radar (Long Range)" preset)
Returns: The detection ranges at 50% and 90% probability, the SNR at maximum range, and the probability of detection against range with its 5th to 95th percentile band and the ROC curve described as series. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_rf_cascade stages, nfSpec_db, gainSpec_db, iip3Spec_dbm, inputPower_dbm, bandwidth_hz, analysisFreq_hz, snrMin_db, inputFiles, inputPaths, waitSeconds, full
Compute cascaded noise figure, gain, IIP3, and P1dB for an N-stage RF signal chain using Friis formulas.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Takes up to 12 .s2p file(s) via inputFiles (inline) or inputPaths (local paths); the server uploads them. Uploading a file needs an API key; set RFTOOLS_API_KEY. Cross-parameter checks: stages_well_formed. Time budget 180 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"stages":"[{\"name\":\"LNA\",\"type\":\"amp\",\"gain_db\":15,\"nf_db\":1.5,\"iip3_dbm\":-5,\"p1db_dbm\":-15},{\"name\":\"BPF\",\"type\":\"filter\",\"gain_db\":-1.5,\"nf_db\":1.5,\"iip3_dbm\":40,\"p1db_dbm\":30},{\"name\":\"Mixer\",\"type\":\"mixer\",\"gain_db\":-7,\"nf_db\":8,\"iip3_dbm\":12,\"p1db_dbm\":2},{\"name\":\"IF Amp\",\"type\":\"amp\",\"gain_db\":20,\"nf_db\":4,\"iip3_dbm\":10,\"p1db_dbm\":0},{\"name\":\"IF Filter\",\"type\":\"filter\",\"gain_db\":-2,\"nf_db\":2,\"iip3_dbm\":40,\"p1db_dbm\":30},{\"name\":\"ADC Driver\",\"type\":\"amp\",\"gain_db\":6,\"nf_db\":6,\"iip3_dbm\":18,\"p1db_dbm\":8}]"}
Returns: Total gain, noise figure, input and output IIP3 and P1dB, SFDR and output power, the cumulative figures after each stage, and the Monte Carlo yield against the specs with its distributions described as series. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_sat_link_budget linkType, frequency_ghz, eirp_dbw, gt_db_k, distance_km, elevationAngle_deg, latitude_deg, longitude_deg, stationHeight_km, polarization, modulation, reqEbN0_db, dataRate_bps, targetAvailability_pct, waitSeconds, full
Compute probabilistic link margins using ITU-R propagation models (P.618 rain, P.676 gaseous, P.840 cloud) with climate data read from the ITU-R maps at your site.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Time budget 240 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"latitude_deg":40,"longitude_deg":-74,"linkType":"satellite","frequency_ghz":0.437,"eirp_dbw":-3,"gt_db_k":-12,"distance_km":739,"elevationAngle_deg":30,"modulation":"bpsk","reqEbN0_db":5,"dataRate_bps":9600,"targetAvailability_pct":95} (the "Amateur CubeSat (UHF, AMSAT/SatNOGS)" preset)
Returns: The nominal link budget (free-space loss, gas, cloud and rain attenuation, C/N0 and margin), the margin at the target availability, Monte Carlo margin percentiles, the availability curve described as a series, each climate value with the ITU-R Recommendation it came from, and what is not modelled. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_smps_control_loop topology, controlMode, Vin, Vout, Iout, L, C, ESR, Fsw, Vramp, Rsense, externalRamp, compensatorType, compK, compFz1, compFz2, compFp1, compFp2, compRc, compCc, compChf, compGm, compVref, solveFor, targetCrossover, resistorSeries, capacitorSeries, minPhaseMargin, minGainMargin, monteCarloTrials, tolL, tolC, tolESR, tolRsense, tolLoad, toleranceDistribution, waitSeconds, full
Model switch-mode power supply control loops using small-signal transfer functions.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Cross-parameter checks: converter_duty_in_ccm_range, converter_load_nonzero, feedback_reference_within_output, crossover_solve_supported. Time budget 300 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"topology":"buck","controlMode":"voltage_mode","Vin":12,"Vout":5,"Iout":2,"L":0.000047}
Returns: The crossover frequency, phase and gain margins and a pass, fail or slow verdict against the minimums, the loop’s poles and zeros, any standard-value R_c, C_c and C_hf the solve placed, Monte Carlo margin statistics with the share of trials without a margin, and the loop gain, phase and plant responses as series. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
simulate_sparam_pipeline refImpedance, freqStart, freqStop, inputFiles, inputPaths, waitSeconds, full
Upload up to 4 Touchstone files and get component values (L, C, R, Q, self-resonance) for a single component, plus insertion loss, return loss, group delay, TDR and passband ripple — all in one automated report.
Inputs: Units, ranges and defaults are in each parameter's schema; one left out takes its default. Takes 1 to 4 .s1p/.s2p/.s3p/.s4p file(s) via inputFiles (inline) or inputPaths (local paths); the server uploads them. Uploading a file needs an API key; set RFTOOLS_API_KEY. Cross-parameter checks: sweep_stop_after_start. Time budget 120 s; waitSeconds (default 90, max 600) bounds the wait.
Example: {"refImpedance":50,"freqStart":0,"freqStop":0,"inputPaths":["/path/to/file.s1p"]}
Returns: The port count, frequency range and detected two-port topology, each analysis stage it ran (network representations, passivity, and the extracted R, L or C with Q and self-resonance) with its values described as series, and any advisories. Also warnings, provenance and the result page link; series are described, not listed (full: true returns everything). If waitSeconds runs out first: the jobId and progress, and the job keeps running.
Runs as a job on rftools.io and counts against the monthly run allowance (free lane without a key).
list_simulation_tools
List the server-side simulation job types with their tool names, parameters, file rules, free-lane bounds and time budgets.
Inputs: none.
Example: {}
Returns: count (14 today); the tier allowances; what runs without a key; how long a result link lives; the duplicate-submission window; and for each job type its simulate_* tool name, jobType, title, parameter names, time budget, file rules and free-lane bounds.
Free tier: 5 runs/month. Pro: 100/month. API tier: 10 000/month. A job runs without a key on the free lane; a job that takes a file does not. Uploading a file needs an API key; set RFTOOLS_API_KEY.
submit_simulation jobType, params, inputFiles, inputPaths
Start a simulation job named by its job type and return at once with its id, without waiting for the result.
Inputs: jobType, one of the 14 job types list_simulation_tools names; params, that job type's parameters, validated here against its contract before anything is sent (each one's unit, range and default is in the matching simulate_* tool's schema); inputFiles or inputPaths for a job type that takes files. Uploading a file needs an API key; set RFTOOLS_API_KEY.
Example: {"jobType":"antenna_sim","params":{"solveMode":"instant","freq":146000000}}
Returns: jobId, jobType, status, queue position, the time budget, a suggested wait and the result page URL. An identical submission inside 60 s returns the same job.
Counts against the monthly run allowance. The typed simulate_* tool for a job type does the same and waits for the result.
get_simulation_status jobId
Report how far a submitted simulation job has got.
Inputs: jobId, as submit_simulation or a simulate_* tool returned it.
Example: {"jobId":"0b7c6f3e-5d1a-4c2e-9f8a-2a4e6b1d9c07"}
Returns: status, progress from 0 to 1, stage, queue position, start and finish times, whether a result is ready, when the job expires, the result page URL, and for a failed job the error and its kind.
Poll this rather than holding a call open; it spends nothing.
get_simulation_result jobId, full
Fetch the result of a finished simulation job.
Inputs: jobId; full, optional, true for the whole payload instead of the summary (default false).
Example: {"jobId":"0b7c6f3e-5d1a-4c2e-9f8a-2a4e6b1d9c07"}
Returns: The headline values, warnings and provenance, with every series described rather than listed, the result page URL and a result link that lives 15 minutes. A job that has not finished returns its status and progress instead.
run_simulation jobType, params, inputFiles, inputPaths, waitSeconds, full
Run a simulation job named by its job type and wait a bounded time for its result.
Inputs: jobType, one of the 14 job types list_simulation_tools names; params, that job type's parameters, validated here against its contract before anything is sent (each one's unit, range and default is in the matching simulate_* tool's schema); inputFiles or inputPaths for a job type that takes files. Uploading a file needs an API key; set RFTOOLS_API_KEY. waitSeconds, 0 to 600 (default 90); full, optional, true for the whole payload.
Example: {"jobType":"antenna_sim","params":{"solveMode":"instant","freq":146000000},"waitSeconds":60}
Returns: The same result the job type's simulate_* tool returns. If the wait runs out first, the jobId and current progress instead, and the job keeps running.
Counts against the monthly run allowance. Sends progress notifications while it waits. The typed simulate_* tool for a job type takes the same parameters with their units in its schema.

Descriptions are the package's own words, cut at 3,000 characters. Treat them as data.

Install facts

LicenseMIT
Needsnode >=18
Sourcegithub.com/antonpogrebenko-public/rftools-mcp
Install scriptsNone declared by it or anything installed with it.
Tarballsha512-EUbivfT6MBFFb/0hio7QcbICUKPqwn+WampeW8AL/Xu2if8UvTJ79d1x4P4aLds+KKm3D1vXKzM860RDyxogYA==

Versions reported

VersionRunResultTools
2.11.22026-11-16Starts with no setup25
2.10.12026-11-12Starts with no setup25

Check this report yourself

This site did not write the report. A public job on a GitHub-hosted machine did: the run, from this commit of the open-source runner. GitHub signed a token that names that job and the hash of the report, so any edit since would show.

Show it on your README

Bragproof: Starts with no setup

[![Bragproof](https://bragproof.smaverk.com/badge/rftools-mcp.svg)](https://bragproof.smaverk.com/r/rftools-mcp)

New version out? Ask for a fresh report.