CST-MCP is an MCP server that drives CST Studio Suite 2026 (modelling, simulation setup, solving, results and evidence export) via CST's own automation API, with 84 tools across 14 categories over local stdio.
Session & project management: health check, detect CST installs, connect/launch Design Environment, create/open/save/close projects, quit all, inspect project info, read message window, list running Design Environments.
Parameters: read, create/update, set, delete design parameters; sweep preview and sweep run (one copied project per case, optional solve and export).
Geometry: brick, cylinder, sphere, cone, torus, elliptical cylinder, bond wire, extrude curve, boolean ops, transform, create/delete/rename/move solids, new components.
Materials: create custom materials (ε, μ, σ, loss tangent), assign to solids, load from CST library.
Ports: add discrete ports (with reference impedance), waveguide ports (multimode, orientation, reference plane), list ports.
Solvers & simulation setup: choose solver, FD/TD/eigenmode configuration, frequency range, boundary conditions, symmetry, background space, mesh type/density (steps per wavelength, smallest feature).
Monitors: add field monitors (far field, E/H field, power flow, current, loss) and list them.
Results & verification: list result tree, read 1D results, read S11 in dB, read reference impedance, port mode info (cutoff, wave impedance), energy/power budget, model audit, frequency overview.
Export & evidence: Touchstone, ASCII/CSV export, summary JSON with solver, band, S11 and efficiencies.
Runtime & meta: built-in command bridge, list/describe/invoke runtime commands, argument templates, pipeline recipes, usage guide, typed wrapper generation, schema catalog, tool manifest, list tools, dynamic dispatch by name, raw VBA and history-block injection.
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., "@CST-MCP build a 2.4 GHz patch antenna, run it, and verify S11"
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.
An MCP server that drives CST Studio Suite 2026 through CST's own automation API
(cst.interface, cst.results): modelling, materials, ports, boundaries, mesh, solver
selection, frequency range, monitors, solver runs, result reading and evidence export.
84 tools · 14 categories · stdio transport · no network access.
New here? Install → Quick start → Verify with the demo project.
This server is a refactor of the CST MCP inside
Cai-aa/CAE-Agent-Hub (MCP/CST/). That
project is MIT-licensed and its copyright notice is retained in LICENSE.
Upstream | Here | |
Tools | 51, in one 623-line | 84 across 14 categories, in a |
Vendored runtime CLI | 824 files | none — a built-in command registry |
Offline checks, CI | none covering this component | 9 gates on every push, Python 3.10 and 3.12 |
Documentation, skills | one README; skills at the hub root | 17 documents, 2 bundled skills |
Added here: guard rails that refuse a history block CST would hang on, mesh sizing derived
from the smallest feature, project overwrite that does not strand a Result/ directory,
and a port verdict instead of raw numbers.
Full comparison: Differences from upstream.
Related MCP server: CST Studio Orchestrator MCP
A model with generic CST knowledge produces automation that looks right and fails in
specific, quiet ways. Every trap below was measured on CST 2026.2; the raw messages are
recorded in tests/evidence/known_failures.md.
Trap | What it looks like |
Evanescent port mode | A waveguide port on a 1.6 mm microstrip cross-section had a 51.9 GHz cutoff and a 6.2 kΩ wave impedance at 2.4 GHz. S-parameters were referenced to 7623 Ω instead of 50 Ω and S11 was a flat −0.6 dB line — easy to mistake for an antenna. The solver had reported success. |
| CST refuses it, and in testing the Design Environment was left permanently unresponsive — every later call hung. |
Library material + parameter change | A library-loaded material does not survive save/reopen, so the next rebuild fails at the solid that uses it. A parameter sweep over such a project fails on every case. |
Overwriting a project by deleting the | A CST project is the file plus a companion directory holding |
Ports in a local coordinate system | Endpoint coordinates are read as global |
The server turns those findings into guards, defaults and refusal messages, so the mistake fails loudly at the tool call instead of quietly in the results.
Category | Tools | Covers |
| 14 | health, detect, connect, project create/open/save/close, messages, raw VBA, history blocks, release |
| 4 | read, create, change, delete design parameters |
| 14 | brick, cylinder, sphere, cone, torus, elliptical cylinder, bond wire, boolean, transform, extrude, component |
| 3 | create, assign, load from library |
| 3 | discrete port, waveguide port, list ports |
| 11 | solver choice, frequency range, FD/TD/eigenmode configuration, boundary, symmetry, background, run |
| 2 | mesh type and density, including |
| 2 | add and list field monitors |
| 2 | result tree, read a 1D item |
| 5 | S11, reference impedance, port info with verdict, energy budget, model audit |
| 3 | Touchstone, ASCII, summary JSON |
| 2 | parameter sweep: preview the case count, then run |
| 16 | built-in command bridge and typed wrapper generation |
| 3 | list tools, full manifest, dynamic dispatch |
The full surface, with parameters and examples, is in
docs/mcp_tools.json — machine-readable, so another agent can read
it directly.
CST Studio Suite 2026 | Commercial software. Not distributed here — obtain and license it separately. Verified against the 2026.2 build. |
Operating system | Windows. CST's automation API is Windows-only. |
Python | 3.10 or newer, able to |
Network | Not required. Configuration is read from a local |
# 1. find CST on this machine and write .env for you
python check_install.py --fix
# 2. verify: Python, packages, .env, the tool registry, and a real MCP handshake
python check_install.py
# 3. point your MCP client at it
# command: python
# args: ["<path to>\\mcp_server.py"]
# cwd: <path to this folder>
# 4. first call
# cst_health_check_tool {}check_install.py exits 0 when ready, 1 on warnings, 2 on problems. The full
walkthrough — including what to do on a machine with no internet access — is in
Installation.
check_install.py proves the server loads. To prove it can actually drive CST —
open a project, build geometry, place a port, set the band, solve — hand the prompt below
to your AI. It installs the MCP and the two skills, then runs a verification task against
the demo project bundled in test_demo/.
Fill in the two placeholders and copy the whole block.
Install this cst-studio-suite-mcp into my local harness (<your harness: dsh, codex,
WorkBuddy, ...>). The MCP path is: <the folder you installed it in>. Also install the two
skills in the skills folder: `cst-studio-suite-mcp` and `cst2026-simulation-execution`.
Then verify the installation through that MCP and those two skills. The verification task:
1. Open the project at `<MCP folder>\test_demo\test_demo.cst`.
2. Create a cube named box, 50 mm per side, material iron.
3. Create a thin sheet 2 mm below the box, 5 mm thick, 50 mm x 50 mm, material PEC.
4. Place an excitation port at the centre of that sheet: a discrete port connecting the
box and the sheet.
5. Set the frequency range to 0-100 MHz.
6. Solve for S-parameters.
When the install and the verification are done, report the files used, the steps taken and
the result.A Chinese version of the same prompt is in README.zh-CN.md.
What a pass looks like — and the two traps worth knowing, namely that the reference impedance must read 50 Ω and that a 50 mm cube at 0–100 MHz is far below resonance so S11 near 0 dB is the correct answer — is in Verify with the demo project.
A complete worked run against live CST: build a model, configure the solver, solve, read the result and export evidence — 30 tool calls, 0 failures. Condensed:
cst_connect_tool {"launch_if_needed": true}
cst_new_project_tool {"project_type": "mws", "path": "…\\123.cst"}
cst_define_parameters_tool {"parameters": {"L": 50, "gap": 2, "tsheet": 5}}
cst_create_brick_tool {"component": "parts", "name": "box", "xrange": ["-L/2","L/2"], …}
cst_add_discrete_port_tool {"port_number": 1, "point1": [0,0,"-gap"], "point2": [0,0,"0"], "impedance": 50.0}
cst_set_solver_tool {"solver": "HF Frequency Domain"}
cst_set_frequency_range_tool {"fmin": 0, "fmax": 100, "unit": "MHz"}
cst_set_mesh_tool {"mesh_type": "Tetrahedral", "steps_per_wavelength": 8}
cst_save_project_tool {"path": "…\\123.cst", "overwrite": true}
cst_run_solver_tool {}
cst_read_s11_tool {"target_frequency": 100}
cst_read_reference_impedance_tool {}
cst_export_touchstone_tool {"filename": "…\\evidence\\123_s11", "impedance": 50.0}The per-call record is in
tests/evidence/mcp_calls_123_report.md.
Everything lives in docs/, indexed in docs/README.md.
I want to | Read |
Install on this machine | |
Prove it works end to end | |
Hand the install to another AI | |
Update an existing installation | |
Start using the server | |
See what a session looks like | |
Browse the tools | |
Know the rules that keep results trustworthy | |
Know what CST 2026.2 does not expose | |
Know the server's own limits | |
Add a tool or a tool family | |
Understand the repository layout | |
Run the verification |
Documentation follows progressive disclosure: each file is short and links to its siblings. Read only the file that answers the current question.
The offline checks need no CST installation and run in CI:
python check_install.py --quick
python tests/smoke_registry.py
python tests/check_mcp_compliance.py
python tests/check_self_description.py
python tests/check_skill_tool_refs.py
python tests/check_skill_layout.py
python tests/check_docs_consistency.py
python tests/test_audit_regressions.py
python tests/test_port_info_verdict.py
python tests/test_save_overwrite.pyThe live runners need a licensed CST and a spare ~2 GB of RAM; they are run by hand, and their results are recorded in Verification.
├── mcp_server.py MCP entry point, registry bootstrap, manifest builder
├── check_install.py installation acceptance check
├── cst_mcp/ server implementation, one module per tool category
├── skills/ two bundled agent skills
├── docs/ documentation, grouped index in docs/README.md
├── tests/ offline gates, live runners, curated evidence
└── .env.example configuration template (`.env` is never committed)Full tree with per-file notes: Layout.
Read AGENTS.md first — it defines the documentation-sync requirement, and
it is enforced by the checks above. Then see CONTRIBUTING.md.
Two ground rules, because the project drives a commercial simulator:
A change includes its documentation. If your change makes a document inaccurate, that document is corrected in the same pull request.
Do not document behaviour you have not verified. Read the implementation, or measure it against CST. Untested claims are removed, not merged.
The server runs locally, speaks MCP over stdio and makes no network requests. Report
vulnerabilities privately — see SECURITY.md.
MIT © 2026 Thompson Labs.
This project does not distribute CST Studio Suite, which is commercial software and must be obtained and licensed separately. It calls the automation API that CST ships.
Add a discrete S-parameter port with an explicit reference impedance (safe for microstrip feeds).
Inputs: point1 (required), point2 (required), port_number (required), label, +2 more. Returns: object
Add a field monitor: far field, E/H field, power flow, current or loss.
Inputs: name (required), field_type (required), domain, frequency, +2 more. Returns: object
Append one named block to the model history tree (geometry, mesh, solver, ...).
Inputs: title (required), vba_code (required). Returns: object
Add a waveguide port on a plane of the calculation domain.
Inputs: xrange (required), yrange (required), zrange (required), orientation (required), +5 more. Returns: object
Assign an existing material to a solid.
Inputs: solid (required), material (required). Returns: object
Combine two solids: add (unite), subtract, intersect or insert.
Inputs: tool (required), target (required), operation (required), title. Returns: object
Call any registered CST MCP tool by name through the registry (dynamic dispatch).
Inputs: tool_name (required), args. Returns: object
Close the active project without quitting CST.
Inputs: no named parameters. Returns: object
Configure the eigenmode solver (number of modes, target frequency).
Inputs: method, n_modes, accuracy, frequency, +1 more. Returns: object
Configure the frequency domain solver: mesh method, sweep type, element order, accuracy, adaption.
Inputs: mesh, order, sweep, accuracy, +3 more. Returns: object
Configure the time domain (transient) solver.
Inputs: accuracy, mesh_type, pulse_widths, double_precision, +2 more. Returns: object
Connect to a running CST Design Environment, optionally launching one.
Inputs: pid, launch_if_needed. Returns: object
Create a bond wire between two points.
Inputs: name (required), height (required), point1 (required), point2 (required), +4 more. Returns: object
Create a rectangular brick (box) as a history block.
Inputs: name (required), xrange (required), yrange (required), zrange (required), +3 more. Returns: object
Create a cone or truncated cone.
Inputs: axis (required), name (required), ranges (required), component (required), +6 more. Returns: object
Create a cylinder along x, y or z.
Inputs: axis (required), name (required), radius (required), ranges (required), +5 more. Returns: object
Create an elliptical cylinder.
Inputs: axis (required), name (required), ranges (required), xradius (required), +6 more. Returns: object
Define a material explicitly (permittivity, permeability, conductivity, loss tangent).
Inputs: name (required), mue, rho, sigma, +5 more. Returns: object
Create a sphere (optionally truncated by top/bottom radius).
Inputs: name (required), center (required), radius (required), component (required), +5 more. Returns: object
Create a torus (ring_radius = ring, tube_radius = tube).
Inputs: name (required), center (required), component (required), ring_radius (required), +5 more. Returns: object
Create or update several parameters at once (the usual first modelling step).
Inputs: parameters (required), save. Returns: object
Delete a design parameter from the parameter list.
Inputs: name (required). Returns: object
Delete a solid from the model.
Inputs: name (required). Returns: object
Detect the CST executable, automation libraries and running Design Environments.
Inputs: no named parameters. Returns: object
Report the power budget and efficiencies at a frequency (radiated / accepted / losses).
Inputs: cst_file, frequency. Returns: object
Export one result tree item to an ASCII/CSV file for external checking.
Inputs: filename (required), tree_path (required), mode. Returns: object
Export the S-parameters as a Touchstone file at a chosen reference impedance.
Inputs: filename (required), impedance, data_format, export_type, +1 more. Returns: object
Extrude a closed planar curve item into a solid.
Inputs: name (required), curve (required), component (required), thickness (required), +4 more. Returns: object
Report the solver, the solver frequency range and every monitor frequency in one view.
Inputs: no named parameters. Returns: object
Mesh generation is not exposed through CST's VBA API.
Inputs: no named parameters. Returns: object
Read every design parameter of the active project (name and value).
Inputs: no named parameters. Returns: object
Read the currently active solver.
Inputs: no named parameters. Returns: object
Check CST install, Python libraries, workspace and running Design Environments.
Inputs: no named parameters. Returns: object
List the PIDs of running CST Design Environments.
Inputs: no named parameters. Returns: object
List every CST MCP tool with its category, summary and parameters.
Inputs: category. Returns: object
List the monitors defined in the project.
Inputs: no named parameters. Returns: object
List the ports defined in the project and their types.
Inputs: no named parameters. Returns: object
List the items of the 3D or schematic result tree.
Inputs: module, cst_file. Returns: object
Add a material to the project from the CST material library.
Inputs: library_path (required), replace, material_name. Returns: object
Read the CST message window (INFO / WARNING / ERROR).
Inputs: limit, errors_only. Returns: object
Audit the built model: solids, materials, volumes and bounding boxes.
Inputs: no named parameters. Returns: object
Move a solid into another component.
Inputs: solid (required), component (required). Returns: object
Create a new (empty) component in the model tree.
Inputs: name (required). Returns: object
Create a new CST project and save it into the workspace immediately.
Inputs: path, project_type. Returns: object
Open a .cst project in the connected Design Environment.
Inputs: path (required). Returns: object
Report the active project, all open projects and the recent CST messages.
Inputs: no named parameters. Returns: object
Close every open project and release the Design Environment process.
Inputs: no named parameters. Returns: object
Read port mode information: cutoff frequency, wave impedance, effective permittivity.
Inputs: cst_file, operating_frequency. Returns: object
Read the S-parameter reference impedance (ZRef) - must match the impedance you intend.
Inputs: cst_file. Returns: object
Read a 1D result tree item (S-parameters, efficiency, power, convergence).
Inputs: tree_path (required), module, cst_file, max_points, +1 more. Returns: object
Read S11 and report it in dB at a target frequency (the usual acceptance check).
Inputs: cst_file, tree_path, target_frequency. Returns: object
Rename an existing solid.
Inputs: new_name (required), old_name (required). Returns: object
Run the configured solver and report CST's own diagnostics on failure.
Inputs: allow_low_memory. Returns: object
Return an argument template for one runtime command.
Inputs: tool_name (required). Returns: object
Describe one runtime command.
Inputs: tool_name (required). Returns: object
Report the built-in runtime command bridge and its commands.
Inputs: no named parameters. Returns: object
Invoke a runtime command by name with JSON arguments.
Inputs: tool_name (required), args. Returns: object
List the runtime workflow recipes.
Inputs: no named parameters. Returns: object
List the runtime commands available through this MCP server.
Inputs: no named parameters. Returns: object
Return the machine-readable usage guide for the runtime family.
Inputs: no named parameters. Returns: object
Execute raw CST VBA immediately (not stored in the history tree).
Inputs: vba_code (required). Returns: object
Save the active project, optionally to a specific path.
Inputs: path, overwrite. Returns: object
Set the background material and the extra space added around the model.
Inputs: mue, epsilon, xmax_space, xmin_space, +5 more. Returns: object
Set the boundary conditions on the six domain sides.
Inputs: all, xmax, xmin, ymax, +3 more. Returns: object
Set the solver frequency range (the band that is actually simulated).
Inputs: fmax (required), fmin (required), unit. Returns: object
Set the mesh type and its density (steps per wavelength, minimum steps).
Inputs: mesh_type, min_step_number, smallest_feature_mm, lines_per_wavelength, +1 more. Returns: object
Change one or more design parameters through the CST parameter list.
Inputs: parameters (required), save. Returns: object
Select the solver (high frequency time domain / frequency domain / eigenmode / ...).
Inputs: solver (required). Returns: object
Set electric/magnetic symmetry planes (halves the solve time).
Inputs: x, y, z. Returns: object
Expand a parameter sweep spec into concrete cases and report the case count. Does not start CST.
Inputs: parameters (required), mode, max_cases. Returns: object
Run a parameter sweep: one copied project per case, parameters applied, optional solve and export.
Inputs: parameters (required), project_path (required), mode, max_cases, +8 more. Returns: object
Alias of cst_runtime_args_template_tool.
Inputs: tool_name (required). Returns: object
Alias of cst_runtime_describe_tool.
Inputs: tool_name (required). Returns: object
Alias of cst_runtime_detect_tool.
Inputs: no named parameters. Returns: object
Generate typed Python wrappers for the runtime commands into a file.
Inputs: category, output_path. Returns: object
Alias of cst_runtime_invoke_tool.
Inputs: tool_name (required), args. Returns: object
Alias of cst_runtime_list_pipelines_tool.
Inputs: no named parameters. Returns: object
Alias of cst_runtime_list_tools_tool.
Inputs: no named parameters. Returns: object
Return the JSON-schema catalog of the runtime commands.
Inputs: category. Returns: object
Alias of cst_runtime_usage_guide_tool.
Inputs: no named parameters. Returns: object
Return the full machine-readable manifest of the CST MCP (write it to a file with out_path).
Inputs: out_path. Returns: object
Transform a solid: translate, rotate, scale or mirror.
Inputs: name (required), operation (required), axis, angle, +8 more. Returns: object
Report the workspace and evidence folders and what they contain.
Inputs: no named parameters. Returns: object
Write a single JSON file summarising solver, frequency range, S11 and efficiencies.
Inputs: out_path (required), target_frequency. Returns: object
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 84 tools
Several tools are explicit aliases or overlapping dispatch mechanisms (e.g., cst_runtime_detect_tool / cst_toolbox_detect_tool, cst_runtime_invoke_tool / cst_toolbox_invoke_tool, plus cst_call_tool and cst_run_vba_tool). While many geometry and solver tools are distinct, the runtime/toolbox/meta families create real confusion about which tool to call.
Almost all tools follow a consistent cst_ prefix, snake_case, and _tool suffix pattern. The main deviation is the runtime vs. toolbox alias naming, which is still readable and predictable.
With 84 tools, this server is far beyond the typical well-scoped range. The count is inflated by duplicate aliases and meta/runtime wrappers, making the surface heavy and hard to manage.
The tool set covers project lifecycle, geometry creation, materials, ports, boundaries, solver configuration, results reading, sweeps, and exports broadly. Some operations such as mesh generation are explicitly unsupported, leaving minor gaps rather than major dead ends.
Physics-based validation of simulation results: receipts with per-check verdicts, via MCP.
Headless CAD engine & MCP server for 2D/3D drafting, solids, DXF/SVG export, and automation.
QuLab MCP remote server (Streamable HTTP) for computational science and lab tools.
MCP server for aerospace calculations: orbital mechanics, ephemeris, DSN operations, ...
