AetherLink SDR MCP
Supports containerized deployment through Docker, enabling portable setup of the AetherLink server with all dependencies included.
Provides testing infrastructure for verifying functionality of radio protocol decoders and hardware interfaces.
Built on Python 3.10+, allowing for extensible development of new radio protocol decoders and hardware support.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@AetherLink SDR MCP scan 100-150 MHz for emergency services signals"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
AetherLink-SDR-MCP: Software Defined Radio Model Context Protocol Server
Control Software Defined Radios and decode radio protocols through an AI-friendly Model Context Protocol interface.
Features
Protocol Decoders: ADS-B aircraft tracking, POCSAG pagers, AIS ship tracking, Meteor-M LRPT satellites, ISM band devices
Built-in pager and AIS decoders: POCSAG and AIS are decoded in Python from the dongle's own samples; no multimon-ng or AIS-catcher required
Zero setup in daily use: the first RTL-SDR is opened automatically and the receiver location is detected automatically
Weather Satellites: Meteor-M2-3/M2-4 LRPT decoding with SatDump
Advanced Analysis: Real-time spectrum analysis, waterfall displays, signal detection, frequency scanning
Audio Recording: Demodulate and record FM/AM audio as WAV files
ISM Band Scanning: Decode 433MHz/315MHz devices (weather stations, sensors, doorbells, tire pressure monitors)
MCP Integration: Seamless integration with Claude Desktop and other MCP clients
Satellite Pass Prediction: Know when Meteor-M is overhead before you start a decode
34 MCP Tools: Complete SDR control through natural language
Related MCP server: SDR MCP Server
Installation
From PyPI (Recommended)
pip install aetherlink
aetherlink --setupThat's it. The --setup command auto-configures Claude Desktop -- it detects your OS, finds the config file, and adds AetherLink without touching your other MCP servers. Then restart Claude Desktop.
Or if you prefer uvx (no install needed):
uvx aetherlink --setupNote: You still need RTL-SDR system drivers installed. See System Dependencies below.
Full Installer (includes system drivers)
macOS / Linux:
curl -fsSL https://raw.githubusercontent.com/N-Erickson/AetherLink-SDR-MCP/main/install.sh | bashWindows (PowerShell):
irm https://raw.githubusercontent.com/N-Erickson/AetherLink-SDR-MCP/main/install.ps1 | iexThe installer handles everything: system drivers, Python package, optional decoders, and Claude Desktop configuration.
Windows users: You also need Zadig to replace the RTL-SDR USB driver with WinUSB. The installer will walk you through this.
System Dependencies
AetherLink requires RTL-SDR drivers installed at the system level:
Tool | macOS | Ubuntu/Debian | Purpose |
RTL-SDR |
|
| Required - SDR drivers (also provides |
dump1090 |
|
| Optional - preferred ADS-B receiver; |
rtl_433 |
|
| Optional - ISM band devices |
SatDump |
| Optional - satellite imaging | |
multimon-ng | Built from source by installer |
| Optional - alternative external POCSAG engine ( |
AIS-catcher or rtl_ais | AIS-catcher or rtl_ais built from source by installer |
| Optional - alternative external AIS engine ( |
libhackrf |
|
| Optional - HackRF One support (no Python package needed) |
git clone https://github.com/N-Erickson/AetherLink-SDR-MCP
cd AetherLink-SDR-MCP
python3 -m venv venv
source venv/bin/activate
pip install -e ".[dev]"Quick Start
1. Point Claude Desktop at AetherLink
aetherlink --setupThis writes the aetherlink entry into your Claude Desktop config (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json, Windows: %APPDATA%\Claude\claude_desktop_config.json, Linux: ~/.config/Claude/claude_desktop_config.json) without touching your other MCP servers, and points it at the exact install you just made. The installers run this step for you.
If you prefer to edit the config yourself, use the interpreter that has AetherLink installed:
{
"mcpServers": {
"aetherlink": {
"command": "/path/to/python",
"args": ["-m", "sdr_mcp"]
}
}
}2. Restart Claude Desktop
Quit completely (Cmd+Q on macOS) and start it again so the server is loaded.
3. Try it
Plug in the RTL-SDR and ask, in Claude Desktop:
What aircraft are overhead right now?or
Analyze the spectrum at 100 MHzThere is no connect step: the first attached RTL-SDR is opened automatically, and the receiver location is detected automatically. Connect to my HackRF is only needed for HackRF hardware or to pick a specific dongle.
Troubleshooting
Server not appearing: Check logs at
~/Library/Logs/Claude/mcp-server-aetherlink.log"Device busy" errors: Only one program can use the SDR at a time. Close GQRX, SDR#, or other SDR software.
Linux device permissions: Add udev rules for RTL-SDR (
/etc/udev/rules.d/20-rtlsdr.rules) and blacklist thedvb_usb_rtl28xxukernel module.E4000 tuner gap: Frequencies 1084-1239 MHz may not work on E4000-based dongles. This is normal hardware behavior.
"No RTL-SDR was detected": check
sdr_list_devices; on Linux make sure the DVB kernel module is blacklisted (the installer does this); on Windows the WinUSB driver must be installed with Zadig.Weak ADS-B reception: 1090 MHz signals are weak. A short indoor antenna only hears aircraft nearly overhead; a 1090 MHz antenna near a window or outdoors makes the biggest difference.
aviation_get_aircrafttells you which receiver program is running and whether it switched tortl_adsb."RTL-SDR library not available ... rtlsdr_set_dithering": pyrtlsdr 0.4 and newer bind a function that only the rtl-sdr-blog driver provides. AetherLink pins
pyrtlsdr<0.4for this reason; if you installed pyrtlsdr yourself, downgrade it or install the rtl-sdr-blog driver.Recordings location: files go to
~/AetherLink/recordingsby default; setAETHERLINK_RECORDINGS_DIRto change it.Testing without hardware: set
AETHERLINK_MOCK_SDR=1to use a mock RTL-SDR;AETHERLINK_MOCK_IQ_FILEcan point at a.npyfile of complex samples that the mock plays back in a loop (useful for exercising the built-in decoders).
Supported Hardware
Device | RX Frequency | TX Support | Status | Tested |
RTL-SDR | 24 MHz - 1766 MHz | ❌ | ✅ Stable | ✅ Yes |
HackRF One | 1 MHz - 6 GHz | ✅ | ✅ Supported via system libhackrf | ⚠️ Not yet verified on hardware |
Nooelec E4000 | 55 MHz - 2300 MHz | ❌ | ✅ Stable | ✅ Yes |
Protocol Support
Protocol | Description | Status |
ADS-B | Aircraft tracking | ✅ Ready |
POCSAG | Pager decoding | ✅ Built-in decoder, no extra software |
AIS | Ship tracking | ✅ Built-in receiver, no extra software |
Meteor-M LRPT | Weather satellites (M2-3, M2-4) | ✅ Ready (SatDump, runs in the background with pass prediction) |
ISM Band | 433MHz/315MHz devices | ✅ Ready |
Protocol Details
ADS-B (1090 MHz):
Uses
dump1090when installed, otherwisertl_adsbfrom the RTL-SDR drivers; if dump1090 hears nothing for 45 s (for example when strong broadband noise swamps its demodulator) the tool switches tortl_adsbautomatically.engine: dump1090/rtl_adsbforces one.Starts at maximum tuner gain (49.6 dB) and lets dump1090-fa adapt it downwards; 1090 MHz signals are weak, and a short, cheap antenna indoors only hears aircraft nearly overhead
pyModeS for DF/CRC-filtered ADS-B message decoding
Defaults to a 120-second capture; set
duration=0to run until stoppedTracks callsign, altitude, speed, heading, vertical rate, message count
Decodes positions from even/odd CPR frame pairs; with a receiver location it also decodes from single frames, shows distance and bearing, and lists nearest aircraft first
Optional aircraft registration/type/operator lookup via hexdb.io
Emits live tracking links for observed ICAO addresses
Verified live: aircraft decoded with positions matching a public ADS-B feed
POCSAG (152/454/929 MHz):
Built-in decoder: channel filter, FM discriminator, automatic frequency control (absorbs dongle ppm error), bit timing recovery, BCH(31,21) error correction
Decodes 512/1200/2400 baud simultaneously (or a single rate on request); alphanumeric, numeric and tone-only pages
Reports whether a signal is present on the channel and the measured carrier offset, so an empty result is explainable
pager_find_frequenciesscans the paging bands for active carriers; common allocations are 152-153 MHz, 454 MHz, 929-931 MHzengine: multimonswitches to an externalrtl_fm | multimon-ngpipeline if you prefer it
AIS (161.975/162.025 MHz):
Built-in receiver: both channels from one capture, burst detection, GMSK demodulation, NRZI/HDLC deframing with CRC-16, shared frequency correction
Frames are armored into NMEA and decoded with
pyais(position reports, static/voyage data); vessels get MarineTraffic linksTracks position, speed, course, heading, name, callsign, ship type, destination
Requires a coastal or waterway location (AIS is line of sight)
engine: externalswitches toAIS-catcherorrtl_aisif installed
Meteor-M LRPT (137 MHz):
Uses
satdumpsubprocess for OQPSK demodulationDigital LRPT transmission with error correction
Decodes visible and infrared channels
Active satellites: Meteor-M2-3 (137.9 MHz), Meteor-M2-4 (137.9 MHz primary, 137.1 MHz backup)
CURRENT WEATHER SATELLITE STANDARD (replaced NOAA APT)
ISM Band (433/315/868/915 MHz):
Uses
rtl_433subprocess for decodingMulti-frequency hopping support
Decodes 200+ device types automatically
Weather stations, sensors, doorbells, tire pressure monitors, remote controls
Common frequencies: 433.92 MHz (EU/Asia), 315 MHz (NA), 868 MHz (EU), 915 MHz (NA)
Available MCP Tools (34 Total)
All frequency arguments are in Hz (for example 152240000 for 152.240 MHz). Tools that need the radio open it automatically (first RTL-SDR); sdr_connect is only needed to pick a specific device or a HackRF. ADS-B, ISM and Meteor decoding run external programs (dump1090, rtl_433, SatDump) that take exclusive control of the radio; Python-side control is paused while one runs and restored with its previous settings when it stops. Pager and AIS decoding are built in and keep the radio under Python control. Tools that return lists also return structured JSON (structuredContent) alongside the text.
The receiver location is detected automatically (city-level IP geolocation, cached, then refined from decoded aircraft positions) and used for aircraft distances, single-frame position fixes and satellite pass prediction. Override it with latitude/longitude arguments or the AETHERLINK_LATITUDE / AETHERLINK_LONGITUDE environment variables.
Core SDR Control (9 tools)
sdr_list_devices- List attached RTL-SDR and HackRF devices with serialssdr_connect- Connect to RTL-SDR or HackRF (by device index)sdr_disconnect- Stop everything and disconnectsdr_set_frequency- Set center frequency in Hzsdr_set_sample_rate- Set sample rate in Hzsdr_set_gain- Set gain (dB or 'auto')sdr_set_ppm- Set RTL-SDR frequency correction in PPMsdr_set_bias_tee- Switch antenna port power for an LNAsdr_get_status- Hardware status, running decoders, and who holds the radio
Aviation (3 tools)
aviation_track_aircraft- Start ADS-B tracking on 1090 MHzaviation_stop_tracking- Stop trackingaviation_get_aircraft- Tracked aircraft with callsign, altitude, speed, heading, position, and distance from the receiver
Pager Decoding (4 tools)
pager_find_frequencies- Scan the VHF/UHF/900 MHz paging bands for likely pager carrierspager_start_decoding- Start built-in POCSAG decoding on a frequency; optional baud rate, gain, duration andengine(multimonfor the external pipeline)pager_stop_decoding- Stop decodingpager_get_messages- Get decoded messages (newest last, filter by age)
Marine (3 tools)
marine_track_vessels- Start built-in AIS ship tracking (both channels); optional gain, duration andengine(externalfor AIS-catcher / rtl_ais)marine_stop_tracking- Stop trackingmarine_get_vessels- Get vessel list
Weather Satellites (4 tools)
satellite_predict_passes- Upcoming Meteor-M passes for your location (rise/set, peak elevation, azimuths)satellite_decode_meteor- Start a Meteor-M2-3/M2-4 LRPT decode with SatDump in the backgroundsatellite_get_status- Progress, results and image list of the current or last decodesatellite_stop_decoding- End a decode early
ISM Band Devices (3 tools)
ism_start_scanning- Start scanning ISM bands (433/315/868/915 MHz, frequencies in Hz) with multi-frequency hoppingism_stop_scanning- Stop ISM band scanningism_get_devices- Get detected devices (weather stations, sensors, etc.)
Analysis (5 tools)
spectrum_analyze- Analyze RF spectrum (FFT, signal detection)spectrum_scan- Scan frequency rangerecording_start/recording_stop- Record raw IQ samples (saved to~/AetherLink/recordings/, override withAETHERLINK_RECORDINGS_DIR)audio_record_start/audio_record_stop- Record demodulated audio as WAV (FM/AM), gap-free streaming capture
HackRF Transmit (2 tools)
hackrf_set_tx_gain- Set transmit gainsignal_generator- Generate and transmit signals
Usage Examples
Track Aircraft
Track aircraft in my areaAfter 30-60 seconds:
Show me the aircraftDecode Pagers
Find active channels first if you don't know one:
Find pager frequenciesThen:
Start decoding pagers on 152.240 MHzWait a few minutes (pager traffic is bursty), then:
Get pager messagesThe report says whether a carrier is present on the channel, so "no messages" and "nothing transmitting" are distinguishable. Stop pager decoding releases the channel. Nothing beyond the RTL-SDR driver is required.
Note: Check RadioReference.com for active pager frequencies in your area.
Track Ships (AIS)
Track vesselsAfter a minute or two:
Show me the vesselsNothing beyond the RTL-SDR driver is required; you do need a location within line of sight of shipping.
Analyze Spectrum
Set frequency to 100 MHz
Analyze the spectrumScan for Signals
Scan from 430 MHz to 440 MHz with 1 MHz stepsRecord Audio from FM Radio
Set frequency to 103.7 MHz
Start audio recording with FM modulation and description "Local FM station"Wait for desired duration (e.g., 30 seconds), then:
Stop audio recordingFiles saved to: ~/AetherLink/recordings/audio_YYYYMMDD_HHMMSS_XXXMHz_FM.wav
Record Raw IQ Samples
Set frequency to 103.7 MHz
Start recording with description "Raw baseband data"Wait for desired duration, then:
Stop recordingFiles saved to: ~/AetherLink/recordings/recording_YYYYMMDD_HHMMSS_XXXMHz.iq
Use case: Advanced analysis, replay, or processing with GNU Radio/SDR#
Meteor-M Weather Satellite (when overhead)
Find the next pass for your location:
When does Meteor-M2-4 pass over 44.0, -97.0 in the next 24 hours?Then, a minute before it rises:
Decode Meteor-M2-4 satellite for 900 secondsThe decode runs in the background. While it runs:
What's the satellite decode status?Requirements:
SatDump installed (
brew install satdump)Satellite pass overhead (
satellite_predict_passescomputes this from current Celestrak orbital elements; needs network access)Ideally a V-dipole antenna tuned for 137 MHz
What you get:
Visible light channel images
Infrared channel images
Composite RGB images
Saved to
~/AetherLink/recordings/meteor_METEOR-M2-4_*/
Tips:
Meteor-M2-4 transmits on 137.9 MHz (primary) or 137.1 MHz (backup)
Best results with satellite elevation >30°
Full pass is typically 10-15 minutes
Use higher gain (40-49 dB) for weak signals
Scan ISM Band Devices
Start ISM scanning on 433.92 MHz and 315 MHz with 30 second hop intervalWait 1-2 minutes for devices to transmit, then:
Show me the ISM devicesCommon devices detected:
Weather stations (temperature, humidity, wind, rain)
Wireless thermometers
Tire pressure monitoring systems (TPMS)
Door/window sensors
Doorbells and remote controls
Soil moisture sensors
Tips:
Weather stations typically transmit every 30-60 seconds
433.92 MHz is common in Europe/Asia
315 MHz is common in North America
Try different frequency combinations:
[433.92, 315]or[868, 915]Increase hop interval for more dwell time per frequency
Development
Project Structure
AetherLink-SDR-MCP/
├── sdr_mcp/
│ ├── server.py # Main MCP server (34 tools)
│ ├── cli.py # aetherlink console entry point (--setup, --version)
│ ├── __main__.py # python -m sdr_mcp entry point
│ ├── hardware/
│ │ ├── base.py # Abstract SDR device base class (sync reads + streaming)
│ │ ├── rtlsdr.py # RTL-SDR interface (pyrtlsdr, gap-free async streaming)
│ │ ├── hackrf.py # HackRF interface
│ │ └── _libhackrf.py # ctypes binding for the system libhackrf library
│ ├── decoders/
│ │ ├── adsb.py # ADS-B aircraft tracker (pyModeS) + cpr.py position decoding
│ │ ├── pocsag.py # POCSAG message store and multimon-ng output parser
│ │ ├── pocsag_native.py # Built-in POCSAG decoder (IQ in, messages out)
│ │ ├── ais.py # AIS NMEA assembler + pyais vessel tracker
│ │ ├── ais_native.py # Built-in AIS receiver (IQ in, NMEA out)
│ │ ├── rtl433.py # ISM band device decoder
│ │ ├── meteor_lrpt.py # Meteor-M LRPT satellite decoder (SatDump)
│ │ └── satellite_passes.py # Meteor-M pass prediction (SGP4 + Celestrak TLEs)
│ ├── analysis/
│ │ ├── spectrum.py # Spectrum analysis, signal detection, IQ/audio recording
│ │ └── channelizer.py # Shared DSP: channel selection, FM discriminator, bit slicer
│ └── utils/
│ ├── validators.py # Input validation and safety checks
│ ├── location.py # Automatic receiver location
│ └── paths.py # Recordings directory (AETHERLINK_RECORDINGS_DIR)
├── tests/ # All test scripts
├── pyproject.toml # Package configuration
└── readme.md # This fileArchitecture
Device Management:
RTL-SDR and subprocess decoders use exclusive device access
Python SDR control and subprocess tools (dump1090, rtl_fm, rtl_433, AIS receivers, SatDump) cannot run simultaneously
Subprocess-based decoders release the Python SDR connection, and
sdr_get_statusreports which program holds the radioStopping a decoder reconnects Python SDR control with the previous frequency, sample rate and gain
Only one Python-side capture (IQ recording, audio recording, spectrum read) runs at a time; a second start is refused instead of leaking file handles
Decoders:
ADS-B:
dump1090subprocess + pyModeS + optional hexdb.io lookupISM Band:
rtl_433subprocess with JSON output + multi-frequency hoppingPOCSAG: built-in decoder in
decoders/pocsag_native.py(channelizer, FM discriminator, AFC, bit slicer, BCH); externalrtl_fm | multimon-ngpipeline as an alternative engineAIS: built-in receiver in
decoders/ais_native.py(both channels, burst detection, GMSK, HDLC/CRC) producing NMEA forpyais;AIS-catcher/rtl_aisas an alternative engineLocation:
utils/location.pyresolves arguments, environment, cache, IP geolocation, then an estimate from aircraft positionsMeteor-M:
satdump livesubprocess running in the background for the pass duration
Recording:
IQ and audio capture use the RTL-SDR's asynchronous USB streaming, so chunks are contiguous
Audio demodulation uses stateful vectorised filters (about 8 ms of CPU per 100 ms of RF at 2.048 Msps)
HackRF is driven through a small ctypes binding of the system
libhackrf; RX buffers are handed to the event loop thread-safely
Available Tools
34 toolsaudio_record_startB
Start recording demodulated audio (FM/AM) at the current frequency to a WAV file
Inputs: modulation, description.
audio_record_stopC
Stop the current audio recording
Inputs: no named parameters.
aviation_get_aircraftC
Get list of currently tracked aircraft
Inputs: max_age, include_inactive, lookup_registrations. Returns: active, aircraft, statistics
aviation_stop_trackingB
Stop tracking aircraft and return the radio to Python control
Inputs: no named parameters.
aviation_track_aircraftA
Start tracking aircraft via ADS-B on 1090 MHz (dump1090, or rtl_adsb from the RTL-SDR drivers). Takes exclusive control of the RTL-SDR until aviation_stop_tracking or the duration elapses.
Inputs: gain, engine, fix_crc, duration, +3 more.
hackrf_set_tx_gainC
Set HackRF transmit gain (0-47 dB)
Inputs: gain (required).
ism_get_devicesB
Get list of detected ISM band devices (weather stations, sensors, etc.)
Inputs: max_age. Returns: devices, scanning, statistics
ism_start_scanningA
Start scanning ISM bands for devices (433/315/868/915 MHz) using rtl_433. Takes exclusive control of the RTL-SDR until ism_stop_scanning.
Inputs: frequencies, hop_interval.
ism_stop_scanningA
Stop ISM band scanning and return the radio to Python control
Inputs: no named parameters.
marine_get_vesselsC
Get list of tracked vessels
Inputs: max_age. Returns: active, vessels, statistics
marine_stop_trackingA
Stop tracking ships and return the radio to Python control
Inputs: no named parameters.
marine_track_vesselsA
Start tracking ships via AIS (161.975 and 162.025 MHz, both channels) with the built-in receiver (no extra software). Runs until marine_stop_tracking or the duration ends. Needs a coastal or waterway location.
Inputs: gain, engine, duration.
pager_find_frequenciesA
Scan the common paging bands (VHF 152-153/157-158 MHz, UHF 454-455/462-463 MHz, 929-932 MHz) for narrowband carriers that are likely pager channels, strongest first. Needs sdr_connect. Follow up with pager_start_decoding on a candidate.
Inputs: gain, bands, min_snr, dwell_time, +1 more. Returns: candidates, bands_scanned
pager_get_messagesC
Get decoded pager messages (newest last)
Inputs: limit, max_age. Returns: active, messages, statistics
pager_start_decodingA
Start decoding POCSAG pager messages with the built-in decoder (no extra software; 512/1200/2400 baud at once). Runs until pager_stop_decoding or the duration ends. Common paging frequencies: 152-153 MHz, 454 MHz, 929-931 MHz; pager_find_frequencies can locate active channels.
Inputs: gain, engine, duration, baud_rate, +1 more.
pager_stop_decodingA
Stop decoding POCSAG pager messages and return the radio to Python control
Inputs: no named parameters.
recording_startC
Start recording raw IQ samples (complex float32) to a file
Inputs: description.
recording_stopB
Stop the current IQ recording
Inputs: no named parameters.
satellite_decode_meteorA
Start decoding a Meteor-M weather satellite LRPT pass with SatDump in the background. Takes exclusive control of the RTL-SDR for the duration. Check progress with satellite_get_status; images land in the recordings directory.
Inputs: gain, duration, satellite.
satellite_get_statusA
Get the status and results of the current or last Meteor-M decode
Inputs: no named parameters. Returns: images, status, running
satellite_predict_passesA
Predict upcoming Meteor-M passes over a location (rise/set times, peak elevation, azimuths) using current orbital elements from Celestrak. Needs network access. Use it to decide when to run satellite_decode_meteor.
Inputs: hours, latitude, longitude, satellite, +2 more. Returns: passes, elements, satellite
satellite_stop_decodingA
Stop the running Meteor-M decode early and return the radio to Python control
Inputs: no named parameters.
sdr_connectC
Connect to SDR hardware (RTL-SDR or HackRF) for Python-side control: spectrum analysis, scanning, IQ and audio recording, HackRF transmit.
Inputs: device_type, device_index.
sdr_disconnectA
Stop all activity and disconnect from SDR hardware
Inputs: no named parameters.
sdr_get_statusA
Get current SDR status: connection, tuning, which decoders are running, and whether an external decoder currently holds the radio
Inputs: no named parameters. Returns: connected, active_decoders
sdr_list_devicesA
List attached RTL-SDR and HackRF devices (index, name, serial) without opening them
Inputs: no named parameters. Returns: devices
sdr_set_bias_teeA
Enable or disable antenna port power (bias tee) for powering an LNA (RTL-SDR Blog V3/V4, HackRF)
Inputs: enabled (required).
sdr_set_frequencyC
Set SDR center frequency in Hz
Inputs: frequency (required).
sdr_set_gainC
Set SDR gain in dB or 'auto'
Inputs: gain (required).
sdr_set_ppmB
Set the RTL-SDR frequency correction in parts per million (from rtl_test -p or a known reference)
Inputs: ppm (required).
sdr_set_sample_rateB
Set the SDR sample rate in Hz (RTL-SDR 225 kHz-3.2 MHz, HackRF 2-20 MHz)
Inputs: sample_rate (required).
signal_generatorA
Generate and transmit a test signal (HackRF only, max 60 s). Transmission on aviation, public safety, cellular, GNSS and other protected bands is refused.
Inputs: frequency (required), signal_type (required), duration, tone_freq.
spectrum_analyzeB
Perform spectrum analysis (FFT, signal detection) at the current frequency
Inputs: window, fft_size, averaging. Returns: signals, peak_power_db, center_freq_hz, noise_floor_db
spectrum_scanB
Scan a frequency range for signals (at most 2000 steps)
Inputs: stop_freq (required), start_freq (required), step, dwell_time. Returns: results, summary
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 34 tools
Tools are cleanly separated by domain prefix (sdr_, aviation_, pager_, marine_, satellite_, ism_, spectrum_, recording_, audio_record_), and the recurring start/stop/get triads make intent obvious. The only mild overlaps are spectrum_scan vs ism_start_scanning (mitigated by rtl_433-specific wording) and recording_start (IQ) vs audio_record_start (WAV), which descriptions do clarify.
Strong, predictable domain-prefix + verb_noun pattern (sdr_set_frequency, aviation_track_aircraft, pager_get_messages, ism_stop_scanning) applied across nearly all 34 tools. Deviations are few: signal_generator (noun phrase, no prefix) and hackrf_set_tx_gain (device prefix instead of sdr_), plus the slightly longer audio_record_start/stop.
34 tools is heavy for a single MCP server and exceeds a comfortable surface; the per-decoder start/stop/get triads multiply quickly. Each group is individually justified by the domain, but marginal entries like signal_generator and hackrf_set_tx_gain could be folded into general SDR controls.
Core lifecycle is well covered: device discovery, connect/disconnect, frequency, sample rate, gain, ppm, bias tee, status, plus spectrum, recording, audio, TX and four decoder families with prediction support. Minor gaps exist around demodulation mode/bandwidth/squelch settings (audio recording implies a demod choice that cannot be set) and no recording file management or listing.
Maintenance
Related MCP Connectors
Real-time planetary signal engine and Model Context Protocol (MCP) server for autonomous AI agents.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Protocol-native energy infrastructure orchestration for AI data centers. Provides 46 MCP tools across 8 grid protocols (IEC-61850, DNP3, Modbus, OCPP, OpenADR, IEEE 2030.5, IEC 60870-5-104, ICCP) with 5 core API primitives: connect, dispatch, settle, comply, and intel. Enables AI agents to programmatically interact with substations, grid interfaces, and energy assets for real-time workload-grid coordination.
214 tools for AI agents over one MCP endpoint: image, video, audio, 3D, data, storage, mail, GPUs.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that enables natural language-driven creation and management of GNU Radio flowgraphs with validated block connections and parameter configurations. It provides tools for searching the GNU Radio block library, detecting SDR hardware, and generating functional signal processing code.8MIT
- AlicenseNot gradedqualityBmaintenanceConversational AI control for Software Defined Radio via the Model Context Protocol.9MIT
- AlicenseNot gradedqualityDmaintenanceEnables natural language control of a live GNU Radio SDR flowgraph, allowing users to tune frequencies, adjust gain, capture IQ samples, analyze spectra, and detect signals through an MCP-compatible client.2MIT
- AlicenseBqualityBmaintenanceEnables AI agents to process RF signals, perform spectral analysis, and execute radar DSP primitives such as Range-Doppler processing and CFAR detection, supporting both file-based and live SDR capture.14MIT