This server enables AI agents to design, simulate, and analyze wire antennas using the NEC2 method-of-moments solver via the Model Context Protocol. Capabilities include:
Antenna design: Create half-wave dipoles, Yagi-Uda beams, quarter-wave verticals with ground radials, full-wave quad loops, and inverted-V dipoles, with customizable frequency, height, wire radius, element counts, radial counts, and droop angle.
Simulation: Run NEC2 frequency sweeps to obtain impedance, VSWR, gain, and radiation patterns.
Export: Generate raw NEC2 card decks for use with external tools like 4nec2 or xnec2c.
Session management: List all active antenna designs and browse built-in antenna types.
Ground models: Support free-space, perfect (PEC), and real (Sommerfeld) ground options.
Integration: Seamlessly works with MCP clients such as Claude Desktop, Claude Code, and Codex CLI, and is part of the eng-mcp-suite for broader RF engineering workflows.
Engine: Wraps the canonical NEC2C implementation for accurate simulations.
Integrates with the NEC2 method-of-moments solver to design and simulate wire antennas, returning impedance, VSWR, gain patterns, and radiation lobes.
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., "@mcp-nec2-antenna Design a 3-element Yagi for 145 MHz"
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.
Design and simulate wire antennas with the NEC2 method-of-moments solver, driven over MCP. Gain patterns, impedance, VSWR, radiation lobes: from your terminal or AI agent.
Quick start · Tools · Workflows · Documentation
mcp-nec2-antenna is an MCP server that wraps NEC2 (Numerical Electromagnetics Code, version 2). The classic method-of-moments wire-antenna solver, so an LLM agent can design, sweep, and analyze HF / VHF / UHF antennas through plain-English tool calls.
Drive it from any MCP client (Claude Desktop, Claude Code, Codex CLI)
or call the NEC2C binary directly via the same card-deck export. Five
parameterized antenna geometries (dipole, Yagi-Uda, ground-plane
vertical, full-wave loop, inverted-V) compile to NEC2 GW/EX/FR/RP cards,
solve with the nec2c reference engine, and return impedance, VSWR,
gain, and front-to-back from a single tool call.
What mcp-nec2-antenna does well:
AI-native via MCP. First-class Model Context Protocol server with 9 tools. Any Claude / LLM agent can drive it.
Reference engine. Uses the canonical NEC2C C implementation. The same solver behind 4nec2, xnec2c, and antenna textbooks.
Parameterized geometries. Five built-in wire antennas with closed-form initial sizing; the agent fills in band + height + element count and gets a ready-to-solve deck.
Three ground models. free-space, perfect ground, real (Sommerfeld) ground: picked per geometry.
AGPL-3.0-or-later. Modifications shared back if served over a network.
Related MCP server: mcp-openems
NEC2C must be on PATH first:
# Ubuntu/Debian
sudo apt install nec2c
# macOS
brew install nec2c
# Arch Linux
yay -S nec2cThen:
git clone https://github.com/RFingAdam/mcp-nec2-antenna.git
cd mcp-nec2-antenna
uv pip install -e .Claude Code:
claude mcp add nec2-antenna -- uv run --directory /path/to/mcp-nec2-antenna mcp-nec2-antennaCodex CLI:
codex mcp add nec2-antenna -- uv run --directory /path/to/mcp-nec2-antenna mcp-nec2-antennaRaw config (Claude Desktop):
{
"mcpServers": {
"nec2-antenna": {
"command": "uv",
"args": ["run", "--directory", "/path/to/mcp-nec2-antenna", "mcp-nec2-antenna"]
}
}
}Then ask your assistant in plain English:
"Design a 5-element Yagi for 435 MHz at 10 m height, simulate it, and tell me the gain and front-to-back."
The agent calls nec2_create_yagi followed by nec2_simulate, and
reports impedance, VSWR, and radiation pattern.
Tool | Purpose | Key arguments |
| Half-wave horizontal dipole |
|
| Yagi-Uda directional beam |
|
| Quarter-wave vertical w/ radials |
|
| Full-wave quad loop |
|
| Inverted-V dipole from a single mast |
|
| Run NEC2 sweep: Z, VSWR, gain, pattern |
|
| Export raw NEC2 card deck (for 4nec2/xnec2c) |
|
| List antennas in the current session | none |
| Show built-in antenna types + characteristics | none |
Full tool reference in docs/tools.md.
Antenna | Typical gain | Pattern | Best for |
Dipole | 2.15 dBi | Omnidirectional | General purpose, portable |
Yagi-Uda | 7–15 dBi | Directional | DX, satellites, weak-signal work |
Vertical | 0–2 dBi | Omnidirectional | Mobile, limited real estate |
Loop | 3–4 dBi | Bidirectional | Low-noise receive, DX |
Inverted-V | 2 dBi | Omnidirectional | Single-mast portable |
Ground models: free-space, perfect (PEC), and real (Sommerfeld two-medium). Pattern step is configurable; default is 5° azimuth/elevation.
mcp-nec2-antenna fits in the following eng-mcp-suite workflow bundles:
rf-design: closed-form trans-line synthesis (lineforge) +
wire-antenna MoM (this server) + circuit/filter sim (mcp-ltspice-qucs).
antenna-bench: antenna design + EMC limit lookup
(mcp-emc-regulations) before lab measurement.
See the suite manifest for the full list of sibling MCPs and bundle definitions.
Quick Start: install through first call.
Tool reference. Every MCP tool, every argument.
Usage examples: practical end-to-end walkthroughs.
Architecture: how this MCP fits in eng-mcp-suite.
This MCP server is part of
An open umbrella for engineering MCP servers across RF, EMC, PCB, signal integrity, EM simulation, and lab test. Same brand, same docs structure, designed to compose. See the full catalog or jump to a sibling:
Domain | Sibling MCPs |
RF / Transmission lines | |
Circuit + filter sim | |
PCB / SI | |
EMC regulatory | |
EM simulation (3D) | |
Diagrams | |
Lab gear |
Contributions are welcome.
Pick a GitHub issue.
Fork + branch (feature/your-thing or fix/your-bug).
Run the local check suite:
uv run pytestOpen a PR: link the issue, request review.
AGPL-3.0-or-later. Relicensed from Apache-2.0 in v0.2.0 to align with the eng-mcp-suite toolkit-wide AGPL move. The underlying NEC2 engine is public-domain US-government code; this wrapper is AGPL-3.0-or-later and is independent of NEC2's public-domain status.
This project is not affiliated with, endorsed by, or sponsored by Lawrence Livermore National Laboratory or any distributor of NEC2. "NEC2" is used here only to identify the electromagnetics code this project interoperates with.
The project name and the logo files in this repository are not part of the licensed work. The licence above grants no permission to use them, except as needed to describe the origin of the work.
Gerald J. Burke (LLNL): original NEC2 Fortran (1981, public domain).
Neoklis Kyriazis (5B4AZ): NEC2C C port, the reference engine this server invokes.
The MCP working group: for the Model Context Protocol specification.
Part of eng-mcp-suite: built for ham radio operators, RF engineers, and AI agents.
Create a half-wave dipole antenna. Returns antenna ID for simulation.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Antenna name | |
| frequency_mhz | Yes | Design frequency in MHz (e.g., 146 for 2m band) | |
| height_m | No | Height above ground in meters (default: 10) | |
| wire_radius_mm | No | Wire radius in mm (default: 1) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries full burden. It mentions returning an antenna ID but omits side effects (e.g., saving, mutating state), required permissions, or any destructive potential. For a creation tool, more behavioral context is needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loaded with the main action and result. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 4 parameters, no output schema, and no annotations, the description is adequate but minimal. It does not explain return format, error cases, or constraints (e.g., frequency range). For a simple creation tool, it covers essentials but leaves gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are documented. The description adds 'half-wave dipole' context implying frequency determines length, but does not elaborate on how parameters like height or wire radius affect the antenna. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description specifies the action ('create'), the resource ('half-wave dipole antenna'), and the return value ('antenna ID for simulation'). It distinguishes from sibling tools by naming the specific antenna type (dipole vs inverted_v, loop, vertical, yagi).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as recommending a dipole for simple omni-directional coverage or pointing to nec2_create_yagi for gain. No when-not-to-use or alternative suggestions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create an inverted-V dipole antenna (requires only one support).
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Antenna name | |
| frequency_mhz | Yes | Design frequency in MHz | |
| apex_height_m | No | Apex height in meters (default: 15) | |
| droop_angle_deg | No | Droop angle in degrees (default: 45) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only states the creation action and support requirement, without disclosing side effects, state changes, or other behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence with no wasted words. It is appropriately sized and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of output schema, the description is fairly complete for a creation tool. It could mention that the created antenna is added to a model list, but it's implied by the context of sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (all parameters have descriptions in the input schema). The description adds no extra parameter meaning beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates an inverted-V dipole antenna and highlights its unique advantage of requiring only one support. This distinguishes it from siblings like nec2_create_dipole.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when only one support is available, but lacks explicit guidance on when to choose this vs. alternatives like a standard dipole or other antenna types.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a full-wave loop antenna (quad configuration).
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Antenna name | |
| frequency_mhz | Yes | Design frequency in MHz | |
| height_m | No | Height above ground in meters (default: 10) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations available; description lacks details on side effects, permissions, or what the antenna creation entails beyond the action itself.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with zero wasted words, clearly stating verb and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Lacks critical context: no output schema, no explanation of 'quad configuration', no prerequisites or constraints beyond parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers all parameters with descriptions; description adds no extra meaning beyond the schema, so baseline score applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool creates a full-wave loop antenna (quad configuration), distinguishing it from siblings like dipoles or verticals.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., when a loop is preferred over a dipole). No exclusions or context provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a quarter-wave vertical antenna with ground radials.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Antenna name | |
| frequency_mhz | Yes | Design frequency in MHz | |
| num_radials | No | Number of ground radials (default: 4) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description lacks behavioral details beyond the act of creation. With no annotations, it does not disclose side effects, state changes, or what happens to existing data. It is too minimal for a creation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is concise and to the point. It could be slightly more informative without losing conciseness, but it does not waste words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema and the creation nature, the description fails to mention what the tool returns (e.g., antenna ID) or any prerequisites. It is incomplete for guiding an agent on full usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All parameters (name, frequency_mhz, num_radials) are fully described in the input schema with 100% coverage. The description adds no extra meaning beyond the schema, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it creates a 'quarter-wave vertical antenna with ground radials,' specifying both the antenna type and configuration. This is a specific verb+resource that distinguishes it from sibling tools like dipoles and loops.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like nec2_create_dipole or nec2_create_yagi. The description implies usage for vertical antennas but does not explicitly state context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a Yagi-Uda directional antenna with specified number of directors.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Antenna name | |
| frequency_mhz | Yes | Design frequency in MHz | |
| num_directors | No | Number of director elements (default: 3) | |
| height_m | No | Boom height above ground in meters (default: 10) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits but only says 'Create'. It does not mention side effects (e.g., saving to database), default values for optional parameters, or any constraints like element length computation. The agent cannot infer the tool's internal behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one sentence with no fluff. It is concise, but could be slightly improved by mentioning that the antenna is added to the list (if that is the behavior). However, it is still effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 4 parameters (2 required), no output schema, and no annotations, the description is too sparse. It does not state what the tool returns, whether it modifies state, or how the created antenna is stored. Essential context for a creation tool is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description hints at 'num_directors' but adds no new meaning beyond the schema. It does not explain parameter interactions or provide examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Create a Yagi-Uda directional antenna', specifying the verb and resource. It also mentions the key parameter 'number of directors', and the tool name itself distinguishes it from sibling tools like 'dipole' or 'vertical'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives (e.g., for directional vs omnidirectional patterns). There is no mention of prerequisites, scenarios, or comparisons with sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the raw NEC2 card deck for an antenna design (for manual editing or external tools).
| Name | Required | Description | Default |
|---|---|---|---|
| antenna_id | Yes | Antenna ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It describes a read operation but does not disclose potential permissions or side effects. Given the tool's simplicity, the description is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, well-structured sentence that conveys the tool's purpose and use cases without any extraneous information. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter, no output schema, and no nested objects, the description is complete. It explains what the tool does and why it would be used, fulfilling all necessary context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter (antenna_id) with 100% schema description coverage. The description adds no additional meaning beyond the schema, so baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves the raw NEC2 card deck for an antenna design, with specific use cases (manual editing or external tools). It distinguishes itself from siblings like nec2_simulate and nec2_list_antennas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly mentions when to use: for manual editing or external tools. While it doesn't state when not to use, the context is sufficiently clear for an agent to choose appropriately among sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all antenna designs in the current session.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description only states functionality without revealing traits like return format, side effects, or whether it is read-only.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single short sentence that is concise and provides the key information. Could be considered slightly under-structured but adequate.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema or annotations; description lacks details on what 'antenna designs' means or what the output includes. Agent may not know how to interpret the list.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist; schema coverage is 100%. Description does not need to add parameter meaning. Baseline for 0 params is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'List all antenna designs in the current session', specifying the action (list) and resource (antenna designs). Distinguishes from sibling creation tools and nec2_list_antenna_types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies use when a list of current session antenna designs is needed, but does not provide explicit when-not or alternative guidance, such as differentiating from nec2_list_antenna_types.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List available antenna types and their characteristics.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as read-only nature or side effects. For a simple listing tool, stating that it is non-destructive would improve transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence. It front-loads the purpose but could be slightly more informative without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, so the description should explain the return format or structure of 'characteristics'. It does not, leaving the agent uncertain about the output's nature. In the context of sibling creation tools, more detail would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, and the baseline for 0 parameters is 4. The description adds no parameter-level detail but that is acceptable since none exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists antenna types and their characteristics. It distinguishes from sibling tools like nec2_list_antennas (which lists existing antennas) and creation tools. However, it could be more specific about what 'characteristics' includes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. It is implied that it is used before creating antennas, but the description does not state this or mention any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run NEC2 simulation on an antenna to get impedance and radiation pattern.
| Name | Required | Description | Default |
|---|---|---|---|
| antenna_id | Yes | Antenna ID from create_* tools | |
| frequency_start_mhz | No | Start frequency for sweep (default: design freq * 0.9) | |
| frequency_end_mhz | No | End frequency for sweep (default: design freq * 1.1) | |
| frequency_steps | No | Number of frequency points (default: 21) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description only mentions the output (impedance and radiation pattern) without disclosing side effects, performance implications, or whether the simulation modifies the antenna state.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no wasted words, directly conveys the tool's action and output.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema; description vaguely mentions impedance and radiation pattern without specifying format or units. The sweep parameters are described in schema but not summarized in the description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage with adequate descriptions for each parameter. The description does not add additional meaning beyond the schema, but expectations for default behavior (e.g., frequency sweep defaults) are not clarified.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool runs an NEC2 simulation on an antenna to obtain impedance and radiation pattern, distinguishing it from creation and listing sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance. Usage is implied after antenna creation, but alternatives or prerequisites are not mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.2.0nec2_create_dipolenec2_create_inverted_vnec2_create_loopnec2_create_verticalnec2_create_yaginec2_get_nec_cardsnec2_list_antenna_typesnec2_list_antennasnec2_simulateScored across 9 tools
Each tool targets a distinct antenna type or action (creation of specific antennas, listing, raw card access, simulation). No overlap in functionality, making it easy for an agent to select the correct tool.
All tools follow the consistent pattern 'nec2_<verb>_<noun>', with verbs like create, get, list, and simulate. The prefix is uniformly applied, and naming is predictable.
With 9 tools, the set covers the essential operations for antenna design and simulation without being excessive. Each tool serves a clear purpose, and the count is appropriate for the domain.
The tool set provides creation of common antenna types, listing, simulation, and raw card access. However, it lacks update or delete tools for antennas, which would complete the lifecycle. Overall, core workflows are covered.
Amateur radio MCP server with band plans, EIRP, cable loss, antenna gains, and more
N2YO MCP — wraps the N2YO Satellite Tracking REST API (n2yo.com)
MCP server for aerospace calculations: orbital mechanics, ephemeris, DSN operations, ...
QuLab MCP remote server (Streamable HTTP) for computational science and lab tools.
