BHX Fab Quote
Server Details
Measure and price laser, plasma, waterjet and CNC jobs from DXF, G-code and STL files
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 4 tools
Each tool targets a distinct input modality or action: DXF cutting analysis, STL CNC estimation, G-code runtime simulation, and retrieval of example rates. There is little overlap, so an agent can select tools based on file type or whether reference rates are needed.
All names use snake_case and start with a clear verb (analyse, estimate, get), with the resource or input context included. The verb choice and preposition patterns vary slightly, e.g. _for_cutting and _from_stl, so the pattern is mostly but not perfectly consistent.
Four tools is well-scoped for a fabrication quoting/estimation service: three calculation paths plus a rates reference. Each tool has a clear role and none feels redundant.
The core estimation paths for DXF, STL, and G-code are present, but the quote lifecycle is not fully covered: sheet nesting is explicitly absent, and only DXF analysis mentions returning a price while CNC/G-code estimates stop at time/material outputs. A consolidated quote or pricing tool and custom rate management would fill notable gaps.
Available Tools
4 toolsanalyse_dxf_for_cuttingAnalyse a DXF for laser, plasma or waterjet cuttingARead-onlyIdempotentInspect
Reads a flat 2D DXF (text DXF, as exported by AutoCAD, Fusion, Inventor and most CAD) and returns the parts, cut length, number of pierces and drawing problems (duplicate lines, open contours, near-miss gaps, holes smaller than the thickness). With a cutting speed it also returns the cutting time per part, including acceleration and pierces; with pricing it returns a price. Sheet nesting is not included.
| Name | Required | Description | Default |
|---|---|---|---|
| dxf | Yes | The DXF file content as text | |
| units | No | Override the drawing units if the file does not state them | |
| machine | No | A preset name (laser, plasma, waterjet) or {accel_mm_per_s2:[x,y,z], corner_tolerance_mm} | |
| pricing | No | Optional: turn the result into a price | |
| material | No | For a material cost from the part area: {density_g_cm3, price_per_kg, utilisation_percent (expected sheet use, default 70)} | |
| quantity | No | How many of each part | |
| thickness_mm | No | Material thickness, used to flag small holes | |
| pierce_time_s | No | ||
| cut_speed_mm_per_min | No | Cutting speed for this material and thickness | |
| machine_rate_per_hour | No | Machine cost per hour, for pricing |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/non-destructive, and the description goes well beyond them: accepted input format (text DXF from AutoCAD/Fusion/Inventor), the assumption of flat 2D geometry, the exact diagnostics reported, and the explicit scope limit that nesting is excluded. That is meaningful behavioral context an agent could not infer from the annotations.
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?
Two dense sentences, front-loaded with the core action and outputs, then the conditional extensions and the scope exclusion. No filler or restatement of the title.
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 10 parameters, nested objects, and no output schema, the description carries the return-value burden and does so by listing the result fields and the two conditional result modes. Minor gaps remain around units handling and failure behavior on malformed files, but nothing essential to invoking it correctly 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 coverage is 90%, so baseline is 3; the description still adds value by explaining the conditional relationship between inputs and outputs (cut_speed → time with acceleration and pierces; pricing → price). It does not clarify units fallback, pierce_time_s, or quantity, but the schema already documents those.
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?
States a specific verb and resource ('Reads a flat 2D DXF') and enumerates the concrete outputs (parts, cut length, pierces, drawing problems), so an agent knows exactly what it gets back. It also scopes the tool negatively ('Sheet nesting is not included'), separating it from nesting tools, and its domain is clearly distinct from the STL/G-code/rates siblings.
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?
Conditional usage is spelled out well: 'With a cutting speed it also returns the cutting time... with pricing it returns a price', which tells the agent which optional inputs unlock which behavior. 'Sheet nesting is not included' is a useful exclusion. No sibling alternative is named explicitly, which keeps it from a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
estimate_cnc_from_stlEstimate CNC machining of a 3D part (before CAM)ARead-onlyIdempotentInspect
Budget estimate for machining a part from an STL: stock block, material removed, surface area, roughing and finishing time at the material removal rates given, and part mass. Based on volume and surface area only; holes and corner radii are not detected from STL. Accepts up to 60,000 triangles.
| Name | Required | Description | Default |
|---|---|---|---|
| up | No | ||
| setups | No | ||
| pricing | No | Optional: turn the result into a price | |
| material | No | Preset (al6061, ms, ss304, brass, pom) or {name, density_g_cm3, rough_cm3_per_min, finish_cm2_per_min, price_per_kg} | |
| quantity | No | ||
| stl_base64 | Yes | Binary or text STL, base64-encoded | |
| allowance_mm | No | Stock allowance per side, default 2 | |
| machine_rate_per_hour | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/non-destructive, so the description is free to add real behavioral context: the estimate is geometry-only, feature-blind to holes and corner radii, and capped at 60,000 triangles. That's exactly the kind of expectation-setting an agent needs. It stops short of saying whether the pricing block changes the return shape.
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?
Three tight sentences: capability first, then limitation, then input cap. No filler. Slightly dense in the first sentence's output list, but every clause carries information.
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 no output schema, the description does a decent job naming what comes back, but for an 8-parameter tool with a nested pricing object and quantity/setups concepts, it leaves the agent guessing how quantity or pricing extras affect the answer and what the numeric result looks like.
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 50%, and the description only gestures at parameters indirectly ('stock block' hinting at allowance_mm, 'material removal rates given' hinting at the material object). Units, defaults, and defaults for up/setups/quantity/machine_rate_per_hour are left entirely to the schema, so it neither compensates nor is required to.
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?
States a specific verb+resource ('Budget estimate for machining a part from an STL') and enumerates the computed outputs (stock block, material removed, surface area, roughing/finishing time, mass). It implicitly separates itself from the DXF and g-code siblings by working on STL geometry, but never names those alternatives.
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 'Based on volume and surface area only; holes and corner radii are not detected' clause is a useful applicability caveat, and 'before CAM' in the title nudges timing. However there is no explicit routing to analyse_dxf_for_cutting for 2D parts or estimate_gcode_run_time for exact CAM time, so when-to-use is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
estimate_gcode_run_timeEstimate the run time of a G-code programARead-onlyIdempotentInspect
Simulates a CNC, laser or plasma G-code program (G0-G3 with arcs and helixes, drilling cycles G73/G81-G89, dwell, tool changes, inch/mm, absolute/incremental) with the machine's rapid speeds, acceleration and tool-change time. Returns the run time, time per tool, the program's size, and warnings such as rapid moves below Z0 or a program bigger than the machine. Accepts programs of up to 3,000 lines.
| Name | Required | Description | Default |
|---|---|---|---|
| gcode | Yes | ||
| dialect | No | fanuc: G4 P in milliseconds (Fanuc, Haas). grbl: seconds (Grbl, LinuxCNC, Mach) | |
| machine | No | Preset (vmc, router, hobby, laser, plasma, waterjet) or {rapid_mm_per_min:[x,y,z], accel_mm_per_s2:[x,y,z], tool_change_s, travel_mm:[x,y,z], corner_tolerance_mm} | |
| pricing | No | Optional: turn the result into a price | |
| process | No | Default: from the machine preset | |
| quantity | No | ||
| pierce_time_s | No | Laser/plasma: time added per pierce | |
| calibration_factor | No | Real time ÷ estimated time from one real job; default 1 | |
| machine_rate_per_hour | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds real operational context beyond that: the simulation model (rapid speeds, acceleration, tool-change time), the supported cycle families, the returned artifacts (run time, per-tool time, program size, warnings), and a hard 3,000-line ceiling. It stops short of saying what happens when the limit is exceeded (error vs. truncation) or how warnings are surfaced.
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?
Three sentences, front-loaded with the simulation action, followed by returns and then the size limit. The long parenthetical of G-code cycles is dense but functional since it lets an agent check program support; only that enumeration slightly slows the read.
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 no output schema, the description does the necessary work of listing what comes back (run time, per-tool time, size, warnings) and flags notable warning cases. For a 9-parameter tool with nested objects, the pricing/quantity/rate parameters remain unexplained in the description, which is the main gap.
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 67%, so the baseline is 3. The description reinforces the machine-model parameters (rapid speeds, acceleration, tool-change time) and dialect handling (inch/mm, absolute/incremental), but leaves pricing, quantity, machine_rate_per_hour and piece-time behavior entirely to the schema, and never explains that pricing turns the result into a quote.
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 states a specific verb and resource ('simulates a CNC, laser or plasma G-code program') and enumerates the supported G-code feature set, which makes the input domain unambiguous. That domain (G-code text) cleanly separates it from siblings like analyse_dxf_for_cutting and estimate_cnc_from_stl without needing to name them.
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?
Usage is only implied: an agent can infer this is the estimator for G-code files rather than CAD/mesh inputs, and the 'up to 3,000 lines' limit guides applicability. There is no explicit when-to-use/when-not statement, no mention of the siblings as alternatives, and no guidance on which process or machine preset to pick.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_example_ratesExample machine and material figuresARead-onlyIdempotentInspect
Returns the example machine presets and material rates this service uses by default. They are starting points, not quotes: a shop should replace them with its own figures.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already establish that this is a safe, read-only, idempotent operation. The description adds a useful behavioral caveat that the returned values are defaults and not authoritative quotes, but it does not describe return format or units.
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?
Two compact sentences with no wasted language. The key point, that these are default example figures rather than quotes, is 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?
For a simple no-parameter getter, the description is adequate, but there is no output schema and the description does not explain the shape or units of the returned presets and rates. The caveat about defaults is helpful but does not fully compensate for that missing return-value 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?
The tool takes no parameters, so parameter semantics are not a concern. The baseline score for a zero-parameter tool 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?
The description states a specific verb and resource: it returns example machine presets and material rates used by default. This distinguishes it from the sibling estimation/analysis tools, though it does not explicitly name those alternatives.
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?
It gives implied usage guidance by saying the figures are starting points, not quotes, and should be replaced by a shop's own values. However, it does not explicitly say when to call this tool versus the estimation siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
- First observed
analyse_dxf_for_cutting - First observed
estimate_cnc_from_stl - First observed
estimate_gcode_run_time - First observed
get_example_rates
Related MCP Connectors
Manufacturing cost of CNC and sheet-metal parts from STEP or DXF: process plan, times, 10 lot sizes.
Cutlist optimization for sheet, linear and roll stock, with grain, kerf, nesting and saw exports.
Quoting, pricing, production and part data for contract manufacturers (3D printing, CNC).
Should-cost of a machined, sheet metal or cast part from its PDF, DXF or STEP drawing, line by line.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables 2D irregular polygon nesting (bin-packing) with tools to design, preview, get reports, and export DXF files for laser cutting or CNC routing.MIT
- AlicenseAqualityAmaintenanceFree, open-source 2D nesting for fixed sheets (laser, CNC, plasma, waterjet, fabric): SVG/DXF import, part-in-part nesting across several sheets, validation and export. Runs as an MCP server, on the command line and in the browser.510MIT

SmartCutofficial
FlicenseNot gradedqualityCmaintenanceSmartCut is a hosted cutting-optimisation API. It turns a list of parts and available stock into machine-ready cutting patterns for sheet materials (plywood, MDF, glass, plastic, sheet metal), linear stock (timber, bar, pipe, extrusion) and roll goods. Guillotine and true-shape nesting modes, with grain direction, per-part orientation locks, edge banding, blade kerf and stock trim.3-- AlicenseNot gradedqualityBmaintenanceEnables an agent to turn furniture measurements into parametric module parts, optimize panel cutting layouts, and export cut lists, labels, PDF/SVG, CSV, or DXF.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.