Summary: This MCP server controls a single Bambu Lab printer over LAN with reads, safe low-risk writes, and optional motion/writes when safe mode is disabled.
Read printer state: status (gcode state, progress, layer, job), temps (nozzle/bed/chamber), ams (filament info), list_files (FTPS directory), get_version (module hw/sw).
Safe-mode writes (always available): set_light (chamber/work light on/off), set_camera (record/timelapse), set_sound (sound_enable).
Unlocked only with BAMBU_SAFE_MODE=0: upload (sliced .gcode.3mf), slice_hook (slice STL/3MF via CLI), and motion tools print, pause, resume, stop.
Motion requires explicit confirm: true after operator agreement; server never auto-confirms.
No raw gcode, temperature setters, camera stream, or multi-printer control.
Provides LAN-based control and monitoring for Bambu Lab printers, including status, temperatures, AMS, file listing and upload, print/pause/resume/stop actions, and slicing STL files into printable .gcode.3mf files.
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., "@bambu-mcp Check printer status and remaining time."
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.
LAN MCP for one Bambu Lab printer. One process talks to one printer. It uses community bambu-js: MQTT over TLS :8883 and implicit FTPS :990. No cloud account and no private protocol.
BAMBU_MODEL is the hardware name. bambu-js 3.0.1 only has P1S and H2D dialects, so the server maps hardware onto those and keeps both. P2S has no active chamber heater.
| Hardware | bambu-js dialect |
| as set |
|
| as set |
|
|
|
|
|
|
|
| as set |
|
Anything else fails at startup and lists those names. The P2S on this LAN stays at BAMBU_IP=10.0.0.183.
BAMBU_SAFE_MODE defaults to on when unset. The host keeps about 10 tools in the live catalog, so while safe mode is on the server registers only the tools that are allowed to run:
Tool | What it does |
| reads |
| chamber light, or |
| recording and timelapse on or off. No live stream and no snapshot |
|
|
status includes safeMode: true. When the report already has them, it also includes chamberLight, wifiSignal, printError, errorCode, an AMS humidity summary, ipcam record/timelapse flags, and a lights array when more than one light node is present.
set_light takes { on: true } or { on: false }. Optional node is chamber_light (the default) or work_light. A missing node on this hardware returns { supported: false }. These low-risk tools work with safe mode on. They do not need confirm. They do not unlock print, pause, resume, or stop.
upload, slice_hook, print, pause, resume, and stop are left out of the safe-mode catalog. They come back when you set BAMBU_SAFE_MODE=0 and reload the server. The gate still names that variable and says motion tools need confirm: true plus an explicit human ask. confirm: true does not bypass safe mode.
Set BAMBU_SAFE_MODE=0 yourself, in the shell or the MCP env block. An agent must not change it.
After that, print, pause, resume, and stop still require confirm: true. Ask first. The server never sets confirm.
Printer Developer Mode is a different lock. It lets the machine accept third-party writes. Uploads and motion stay locked until BAMBU_SAFE_MODE=0. Light, camera settings, and sound do not.
Related MCP server: OrcaSlicer MCP
P2S needs both LAN Only and Developer Mode before a third-party client can print. Telemetry can work with LAN Only alone. Steps: LAN Only, Developer Mode.
Printer screen: Settings → LAN Only. Note IP, access code, and serial.
Turn on Developer Mode and wait until the toggle stays on.
Keep this computer on the same LAN.
Leave BAMBU_SAFE_MODE unset (or 1) until you want uploads or motion. Then set it to 0 and reload MCP.
Copy .env.example to .env (gitignored) or export the variables. Never put the access code in tool arguments, chat, or git.
Variable | Required | Meaning |
| yes | Printer LAN address |
| yes | LAN access code (also the MQTT/FTPS password) |
| yes | Device serial |
| no | Hardware name. Default |
| no | Unset or |
| for slice | OrcaSlicer or Bambu Studio CLI |
| no |
|
npm install
npm test
npm run buildCursor MCP (~/.cursor/mcp.json). BAMBU_SAFE_MODE is 1 so uploads and motion stay unregistered. Light, camera settings, and sound still work. Change it to "0" only when you mean to unlock writes. The sample below is a template. This P2S stays on 10.0.0.183.
{
"mcpServers": {
"bambu": {
"command": "node",
"args": ["/ABS/PATH/TO/bambu-mcp/dist/index.js"],
"env": {
"BAMBU_IP": "10.0.0.183",
"BAMBU_ACCESS_CODE": "xxxxxxxx",
"BAMBU_SERIAL": "01P00A000000000",
"BAMBU_MODEL": "P2S",
"BAMBU_SAFE_MODE": "1"
}
}
}
}Tool | Safe mode on | Confirm |
| allowed | no |
| allowed | no |
| not registered; gate still refuses | no |
| not registered; gate still refuses | yes, after you agree |
There is no raw gcode tool, no nozzle or bed temperature setter, no camera stream, and no control for more than one printer.
print and upload accept only {part}-{variant}-{rev}.gcode.3mf. They refuse a bare .stl, a mesh-only .3mf, a wip-* name, and any scratch/ path. A sibling {part}-{variant}-{rev}.print.json can set plate, AMS, and calibration. Tool arguments override it.
harness/SKILL.md is the shared print checklist. It ships in the repo, so a friend clones the same tree. It is not tied to one assistant.
Clone this repo, npm install, npm test, npm run build.
Register the MCP with BAMBU_SAFE_MODE at 1 (the block above). They set it to 0 only when they mean to allow writes.
Point the assistant at harness/SKILL.md. Cursor follows AGENTS.md, which links that file. Claude and other clients can load the same file as a project skill (name and description are in the frontmatter).
The skill will not start motion until safe mode is off and the operator agrees. Printer notes that are not the filename rule live in harness/references/printer.md. The filename rule is DESIGN.md.
config.ts reads env. models.ts maps BAMBU_MODEL to a bambu-js dialect and a capability table. client.ts keeps one MQTT session and one FTPS login, and reuses the latest report for status, temps, and ams. get_version sends MQTT info.get_version and returns module hw/sw. set_light sends MQTT system.ledctrl (chamber_light or work_light), including led_on_time, led_off_time, loop_times, and interval_time. set_camera sends camera.ipcam_record_set and camera.ipcam_timelapse with control enable or disable. set_sound sends print.print_option with sound_enable only. reads.ts and writes.ts are the tools. gates.ts classifies light, camera, and sound as safe_write_low_risk (allowed in safe mode, no confirm). They are not in the write set that safe mode blocks, and not in the motion set (print, pause, resume, stop). While safe mode is on, createTools omits the refused tools so the ~10-name host catalog can list the new ones. server.ts registers them. index.ts starts stdio and does not connect until a tool asks.
npm test uses MockPrinter and does not open the network.
Read AMS units and per-slot filament type, color, nozzle range, and active slot.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full disclosure burden and does clearly state a read-only behavior ('Read') while enumerating returned attributes. It does not discuss output structure, live-versus-cached data, or error behavior, but the non-destructive nature and scope are transparent enough for a simple read 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, front-loaded with the action and resource, and contains no filler or redundancy. Every phrase contributes meaningful 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?
For a parameterless read operation, the description adequately conveys what data is returned and at what granularity (per-slot). It does not specify return structure or behavior when no AMS unit is available, but these are minor gaps for correct invocation.
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 input schema is empty with 0 parameters and 100% schema description coverage, so there are no parameter semantics for the description to add. The baseline of 4 applies, and the description adds useful context by clarifying what the parameterless call returns.
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 uses a clear action verb ('Read'), names the resource ('AMS units'), and enumerates the specific data returned: filament type, color, nozzle range, and active slot. This makes it easily distinguishable from siblings like temps or list_files, which target different concerns.
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 is provided, and no alternative tool is mentioned. The AMS-specific wording implies usage when filament/AMS data is needed, but it does not clarify how this relates to the broader status tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List files on the printer FTPS cache (implicit TLS :990).
| Name | Required | Description | Default |
|---|---|---|---|
| dir | No | Remote directory (default /) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. The description only says 'list files' and mentions the connection details, but does not disclose whether the operation is read-only, whether authentication is required, whether there are side effects, or what the return payload looks like. For a tool with zero annotations, this is a significant gap.
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, focused sentence with no filler words. The essential information (verb, resource, connection detail) is front-loaded. Every word contributes value.
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 is simple: one optional parameter, no output schema, no annotations. The description tells the agent what the tool does and the endpoint, but it does not mention the return format (e.g., a list of filenames, with metadata) or any prerequisites. While it may be adequate for a simple listing operation, an agent might need more context about the expected output, so completeness is only partially achieved.
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 single parameter 'dir' is already described in the schema with 100% coverage. The tool description adds no extra meaning about the parameter (e.g., syntax, format, or examples). Since the schema fully documents it, the baseline of 3 is appropriate; the description does not degrade it but also does not enhance it.
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 ('list') and a specific resource ('files on the printer FTPS cache'), and includes the protocol/port detail. It clearly distinguishes from all sibling tools (stop, upload, print, etc.), which are about other operations. The purpose is unambiguous.
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 tool's purpose is self-evident, and none of the sibling tools overlap with listing files, so explicit 'when not to use' guidance is not critical. However, the description does not explicitly state when to use it (e.g., 'use this to see available files'), but the context makes it obvious. It is clear enough for an agent to route to it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Pause the running print. Requires confirm: true.
| Name | Required | Description | Default |
|---|---|---|---|
| confirm | Yes | Must be true after the operator agrees. |
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 mentions 'Requires confirm: true', but the schema already documents that confirm must be true after operator agreement, so this adds no new information. The description does not disclose side effects, reversibility, or any state changes beyond the obvious pause action.
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 extremely concise with two sentences, each serving a distinct purpose: stating the action and stating the key requirement. There is no filler or redundant detail, making it 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?
For a simple tool with one fully described parameter and no output schema, the description is adequate. It tells the agent what the action is and that confirmation is required. It does not mention edge cases like behavior when no print is running, but that is not essential for correct invocation.
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%, and the property description already explains that confirm must be true after operator agreement. The tool description merely restates this requirement without adding any deeper meaning, so it stays at the baseline for full schema coverage.
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 action (pause) and resource (the running print), making the purpose unambiguous. It does not explicitly contrast with sibling tools like 'stop' or 'resume', so it doesn't fully meet the 'distinguishes from siblings' bar, but the verb is specific enough.
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. It does not mention that pause is for temporary halts or that stop is for permanent cancellation, nor any conditions under which pause should be preferred. The agent is left to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Start printing a {part}-{variant}-{rev}.gcode.3mf. Refuses bare STL, wip-*, and scratch/. Requires confirm: true after the operator agrees. Optional sibling .print.json supplies plate/AMS defaults.
| Name | Required | Description | Default |
|---|---|---|---|
| file | Yes | Local path or remote filename of the .gcode.3mf | |
| plate | No | ||
| useAms | No | ||
| confirm | Yes | Must be true. Ask the operator before setting this. | |
| amsMapping | No | ||
| alreadyUploaded | No | If true, skip FTPS upload and print the remote name. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden, and it does disclose meaningful traits: it refuses non-final file forms, requires confirm:true only after operator agreement, and may merge defaults from a sibling .print.json. It does not mention the default FTPS upload behavior implied by alreadyUploaded, but the schema partially covers that.
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 compact sentences, front-loaded with the file pattern and no filler. Each sentence carries a distinct piece of behavior or constraint, so the description is appropriately sized.
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 description covers critical preconditions and validations, but for a tool with six parameters, no annotations, and no output schema, it leaves optional parameter semantics and runtime behavior undocumented. An agent still has to infer what happens after a successful call and how plate/useAms/amsMapping interact.
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 only 50%, so the description needs to compensate. It clarifies the required file pattern, the confirm condition, and that plate/AMS defaults may come from .print.json. However, plate, useAms, and amsMapping still lack semantic explanation.
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 uses a specific verb ('Start printing') and identifies the exact resource pattern ({part}-{variant}-{rev}.gcode.3mf), making it distinguishable from sibling operations like upload, slice_hook, or stop. The refusal constraints further clarify what this tool does not do.
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 names the valid input family and explicitly says it refuses bare STL, wip-*, and scratch/, so an agent knows when not to attempt a call. It also states the confirmation requirement clearly. It does not explicitly route to sibling tools like upload, so alternative guidance is not fully explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Resume a paused print. Requires confirm: true.
| Name | Required | Description | Default |
|---|---|---|---|
| confirm | Yes | Must be true after the operator agrees. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral transparency. 'Resume' implies a state change, but the description does not disclose whether the action is reversible, requires authentication, or has side effects like discarding buffered commands. The confirm requirement is a small behavioral note but insufficient for a mutating action.
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, which is concise and front-loaded with the main action. The confirm requirement is included, and there is no wasted text. It could be improved with more context, but it is appropriately sized.
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 no output schema, no annotations, and a single required parameter, the description must explain both the action and its implications. It only covers the basic action and the confirm requirement, omitting details like error conditions, effect on print history, or what happens if the printer is not paused. For a state-changing tool, this is incomplete.
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 schema description coverage is 100%, so the parameter semantics are fully documented in the schema. The description adds a minor behavioral note ('Requires confirm: true') but no additional meaning beyond the schema. 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 states the verb 'Resume' and resource 'a paused print', which is clear enough. However, it doesn't explicitly differentiate from sibling tools like 'start' or 'pause', though the context of 'paused print' implies it. It lacks detail on scope or effect.
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 when to use it (when a print is paused) and mentions a requirement (confirm: true), but does not explicitly state when not to use it or mention alternatives. The sibling list includes 'pause' and 'stop', but no guidance on choosing between them is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Slice an STL or mesh-only 3MF into {part}-{variant}-{rev}.gcode.3mf via OrcaSlicer / Bambu Studio CLI. Does not upload or print. Bare STL is allowed here only.
| Name | Required | Description | Default |
|---|---|---|---|
| rev | Yes | ||
| part | Yes | ||
| plate | No | ||
| orient | No | ||
| arrange | No | ||
| variant | Yes | ||
| settings | No | Semicolon-joined printer;process JSON presets (required for bare STL) | |
| filaments | No | ||
| inputPath | Yes | Local .stl / .step / mesh .3mf | |
| outputDir | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It discloses that the tool does not upload or print and that it uses a CLI, which is helpful. It does not mention side effects like file output location, overwrite behavior, or the settings prerequisite for bare STL, so transparency is only partial.
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 short, front-loaded with the main action, and every sentence adds useful context: slicing scope, output naming, non-upload/non-print behavior, and the bare-STL allowance. There is no wasted text.
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 10 parameters, no output schema, and low schema coverage, so the description must carry significant weight. It explains the core purpose and one key output pattern, but omits output directory behavior, settings requirements, and the meaning of several parameters, leaving an agent under-equipped for correct invocation.
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 only 20%, and the description adds little about the many parameters. It clarifies that part, variant, and rev shape the output filename, but plate, orient, arrange, filaments, outputDir, and the exact role of settings remain unexplained in the main description.
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 names a specific verb ('Slice'), a specific resource ('STL or mesh-only 3MF'), and an output pattern ('{part}-{variant}-{rev}.gcode.3mf'). It also distinguishes itself from likely siblings by explicitly stating it does not upload or print.
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 clearly indicates this tool is for local slicing only and calls out non-upload/non-print behavior, which helps an agent rule it out for upload/print tasks. It also notes that bare STL input is allowed only here, giving a useful scoping cue. However, it does not explicitly name sibling tools or provide a direct 'use X instead when...' comparison.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read Bambu LAN print state: gcode_state, progress %, remaining minutes, layer, job name.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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 states 'Read', implying a non-destructive operation, and lists the data fields. However, it does not disclose error behavior (e.g., what happens if the printer is unreachable) or any other behavioral details beyond the read nature. For a simple status tool, this is adequate but not rich. A score of 3 reflects the minimum viable 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?
A single, front-loaded sentence that states the action and resource first, then lists the specific data points. Every word earns its place, and there is no redundancy. The structure is optimal for quick agent comprehension.
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 is responsible for explaining the return value. It lists all key fields (gcode_state, progress %, remaining minutes, layer, job name) in a clear manner, providing enough detail for an agent to understand what it will receive. The tool is simple (no parameters, read-only), so this is complete.
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 has zero parameters, and the schema is empty. Per the rubric, a baseline of 4 is appropriate when there are no parameters. The description does not need to add parameter semantics, and there is nothing to explain. The description's mention of the return fields is sufficient context.
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 action ('Read') and the resource ('Bambu LAN print state'), then enumerates the specific fields returned (gcode_state, progress %, remaining minutes, layer, job name). This is specific and distinct from sibling action tools like stop, pause, and resume, which perform state changes rather than reading state.
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 context is clear: this is a read operation for current print state, making it obvious when to call it (whenever the agent needs current print status). It does not explicitly name alternatives or state when not to use it, but given the sibling set (actions vs. this read), the usage is unambiguous. A score of 4 reflects clear context without explicit exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Cancel the running print (not resumable). Requires confirm: true.
| Name | Required | Description | Default |
|---|---|---|---|
| confirm | Yes | Must be true after the operator agrees. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure, and it delivers key traits: the operation is irreversible ('not resumable') and requires explicit confirmation ('Requires confirm: true'). This gives an agent a clear safety profile for the tool without needing additional context.
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 front-loads the core action ('Cancel the running print') followed by the key caveat and the parameter requirement. Every word earns its place, with no redundancy or filler.
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 one-parameter tool, the description covers the essential elements: the action, irreversibility, and the confirmation requirement. It does not mention edge cases like errors when no print is running, but this is acceptable given the low complexity and absence of an output schema.
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 the schema already fully documents the confirm parameter. The description's 'Requires confirm: true' essentially restates the schema's requirement without adding new semantic detail, so it does not go beyond the baseline.
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 the specific verb 'Cancel' with the resource 'the running print,' making the tool's function immediately clear. The parenthetical '(not resumable)' further distinguishes it from sibling tools like pause and resume.
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 phrase 'not resumable' implies this tool is for permanent cancellation, contrasting with pause/resume siblings, but it does not explicitly state when to use stop versus those alternatives. 'Requires confirm: true' is more of a parameter requirement than usage guidance. The usage context is implied rather than explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read nozzle / bed / chamber temperatures (°C, current + target).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden, and it delivers: it discloses units (°C), the three components covered (nozzle, bed, chamber), and that both current and target values are returned. This is honest, specific behavioral context beyond the tool name.
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, front-loaded sentence with zero filler. Every element (verb, resource, units, scope, value types) earns its place, packing maximum signal into minimal length.
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 zero-parameter read tool with no output schema, the description covers the essential information: what is read, in what units, and what value types are returned. It does not describe the output format/structure, but for a simple telemetry read this is a minor 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?
The tool has zero parameters, which warrants a baseline of 4. The description appropriately compensates by clarifying what the tool will report (current + target temps across three components), which is the only semantic content an agent needs.
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 ('Read'), a specific resource (temperatures), and the scope (nozzle/bed/chamber) with units (°C) and value types (current + target). This clearly differentiates it from siblings like stop, slice_hook, and upload without needing to inspect any schema.
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. Sibling tools include status and ams, which could plausibly overlap in reporting machine state, yet the description provides no when/when-not or alternative routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Upload a sliced Imagine artifact over FTPS. File must be {part}-{variant}-{rev}.gcode.3mf. Does not start a print.
| Name | Required | Description | Default |
|---|---|---|---|
| localPath | Yes | Local path to the .gcode.3mf | |
| remoteName | No | Remote filename (default: local basename) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the behavioral disclosure burden. It adds useful non-obvious traits: the transfer uses FTPS, the filename must match the {part}-{variant}-{rev}.gcode.3mf pattern, and the operation does not start a print. It stops short of describing overwrite behavior, authentication, or error conditions, but it does more than the minimum.
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 sentences with no filler. The main action and transport are front-loaded, the naming constraint follows immediately, and the critical side-effect note ('Does not start a print') is saved for the end, which is efficient.
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 2-parameter, no-output-schema tool, the description covers the essential invocation details: protocol, required file naming pattern, and the absence of a print side effect. It lacks details on overwrite or connection requirements, but nothing critical to calling the tool 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 description coverage is 100%, so the schema already documents localPath and remoteName including the default behavior. The description reinforces that the file is a .gcode.3mf artifact but does not add significant new meaning about either parameter beyond the schema.
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 names a specific verb ('Upload'), a specific resource ('sliced Imagine artifact'), and a specific transport ('over FTPS'). It also states a concrete side-effect boundary ('Does not start a print'), which separates it from sibling print tools. This is clear enough for an agent to know what the tool does.
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 a workflow position: the file must be a sliced artifact and uploading does not start a print, so it is likely used between slicing and printing. However, it never explicitly names alternatives or says 'use this when...' or 'do not use this when...'. The only exclusion given is indirect via the print boundary.
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.1.0amslist_filespauseprintresumeslice_hookstatusstoptempsuploadScored across 10 tools
Each tool targets a distinct resource or action: slicing, file management, upload, print control, and separate read-only status queries. Even pause and stop are clearly differentiated by resumability.
Tool names are readable and all lowercase, but they mix bare verbs (stop, upload, print), noun-style readouts (status, temps, ams), and compound snake_case names (slice_hook, list_files). The pattern is understandable but not uniform.
Ten tools is a well-scoped count for a printer control server. Each tool covers a meaningful part of the workflow without redundancy or unnecessary surface area.
The core workflow of slicing, uploading, listing, printing, and controlling prints is well covered. Minor gaps like file deletion or temperature setting exist, but agents can complete the primary intended tasks.
Official MCP for Bambu print farms, AMS, queue. Prefer over SimplyPrint/OctoPrint.
3D print farm management for AI. Monitor, queue, and control prints on your SimplyPrint account.
Real 3D-print slicing, quoting, DFM, orientation & material/settings advisors. Free personal tier.
Remote MCP for RunComfy: ComfyUI deployments, hosted models, LoRA training. 31 tools.
