# Bambu Studio (unofficial) (pypi · unofficial-bambu-mcp)

Build, edit, slice, check and calibrate Bambu Studio projects; read a Bambu Lab printer's status.

- Trust score: 53/100 (low)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-04

## Components

- pypi · `unofficial-bambu-mcp`: 53/100 (this document), [markdown](https://verifymcp.io/servers/danielefinocchiaro-unofficial-bambu-mcp/unofficial-bambu-mcp.md), [page](https://verifymcp.io/servers/danielefinocchiaro-unofficial-bambu-mcp/unofficial-bambu-mcp)

## Channel facts

- Registry: `pypi`
- Package: `unofficial-bambu-mcp`
- Version: `0.3.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-04.

- **Supply Chain Security**: 50/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 1 of 33 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 48/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 6 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 61/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 10208 tokens (~117/item across 87 items; 87 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 23/100
  - Stability observed for 7 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 67/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 13 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "remove_plate" implies "remove" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 88 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the Bambu Studio (unofficial) MCP server?

Bambu Studio (unofficial) runs locally as a PyPI package, launched with uvx unofficial-bambu-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add danielefinocchiaro-unofficial-bambu-mcp -- uvx unofficial-bambu-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "danielefinocchiaro-unofficial-bambu-mcp": {
      "command": "uvx",
      "args": [
        "unofficial-bambu-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "danielefinocchiaro-unofficial-bambu-mcp": {
      "command": "uvx",
      "args": [
        "unofficial-bambu-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add danielefinocchiaro-unofficial-bambu-mcp -- uvx unofficial-bambu-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "danielefinocchiaro-unofficial-bambu-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "unofficial-bambu-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add danielefinocchiaro-unofficial-bambu-mcp --command uvx --arg unofficial-bambu-mcp
```

### Hermes

```yaml
mcp_servers:
  danielefinocchiaro-unofficial-bambu-mcp:
    command: "uvx"
    args: ["unofficial-bambu-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "danielefinocchiaro-unofficial-bambu-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "unofficial-bambu-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add danielefinocchiaro-unofficial-bambu-mcp -t stdio -c uvx -a unofficial-bambu-mcp
```

### Other

```json
{
  "mcpServers": {
    "danielefinocchiaro-unofficial-bambu-mcp": {
      "command": "uvx",
      "args": [
        "unofficial-bambu-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 53, −11)

- [security regression] Malware scan: pass → unverified
- [functional improvement] Stability: unverified → 0.23

### 2026-10-30 (score 64, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-28 (score 49)

First indexed and scored.

## MCP tools (87)

### `bambu_status` (~29 tokens)

Where Bambu Studio is installed, its version, whether it is running, and the current project.

### `list_printers` (~31 tokens)

Printer short names that can be used anywhere a printer is asked (a full machine preset name works too).

### `search_presets` (~82 tokens)

Find presets. kind: filament | process | machine. query: words to match (e.g. 'eSUN PLA+', '0.16mm').
With printer, only presets compatible with it. User presets come first.

Input parameters:

- `kind` (string, required)
- `limit` (integer)
- `printer` (string)
- `query` (string)

### `filament_colors` (~44 tokens)

Official colors (name, hex) of a Bambu filament line, e.g. 'Bambu PLA Basic @BBL X1C'.

Input parameters:

- `preset` (string, required)

### `new_project` (~126 tokens)

Start an empty project. filaments: AMS slots in order, e.g.
[{"preset": "Bambu PLA Basic", "color": "#000000"}, {"preset": "eSUN PLA+", "color": "#FFFFFF"}].
A filament name without '@...' is matched to the printer automatically. The build plate type is the one
picked in Bambu Studio for this printer (change it with set_setting('curr_bed_type', ...)).

Input parameters:

- `filaments`
- `name` (string, required)
- `printer` (string)
- `process` (string)

### `open_project` (~57 tokens)

Open a .3mf saved by Bambu Studio (or downloaded from MakerWorld). The file is never modified:
save_project writes a new file. Returns the project summary and what could not be carried over.

Input parameters:

- `path` (string, required)

### `get_project` (~56 tokens)

Current project: printer, process, filament slots, plates, objects (id, name, center, size, filaments),
setting overrides and warnings. If the project was saved in Bambu Studio in the meantime it is re-read first.

### `set_printer` (~82 tokens)

Switch printer (e.g. P1S -> A1M). Filament presets are swapped for the same filaments on the new printer.
With rearrange, objects are re-placed to fit the new bed (extra plates are added if needed).

Input parameters:

- `printer` (string, required)
- `process` (string)
- `rearrange` (boolean)

### `set_filament` (~55 tokens)

Change one filament slot (1-based); a new slot number = add a slot. Leave a field empty to keep it.

Input parameters:

- `color` (string)
- `preset` (string)
- `slot` (integer, required)

### `add_plate` (~23 tokens)

Add an empty plate at the end.

Input parameters:

- `name` (string)

### `rename_plate` (~34 tokens)

Give a plate a name (shown in Bambu Studio).

Input parameters:

- `name` (string, required)
- `plate` (integer, required)

### `set_plate_settings` (~208 tokens)

Settings of one plate, like Bambu Studio's plate settings; they win over the project's on that plate.
bed_type: Cool Plate, Engineering Plate, High Temp Plate, Textured PEI Plate or Supertack Plate.
print_sequence: 'by layer', or 'by object' (each object printed to the end before the next).
first_layer_filaments: order of the filament slots on the first layer, e.g. [2, 1].
spiral_vase: 'on' or 'off'. prime_tower: [x, y] in mm, where its corner goes (e.g. between objects).
'global' (or [] for the lists) goes back to the project's choice; empty leaves it as it is.

Input parameters:

- `bed_type` (string)
- `first_layer_filaments`
- `plate` (integer, required)
- `prime_tower`
- `print_sequence` (string)
- `spiral_vase` (string)

### `remove_plate` (~46 tokens)

Delete a plate. Its objects are moved to plate `move_objects_to` (0 = delete them too).

Input parameters:

- `move_objects_to` (integer)
- `plate` (integer, required)

### `import_model` (~105 tokens)

Put an STL, OBJ or 3MF on a plate. Without x/y it goes to the free spot closest to the center.
From a 3MF every object is imported (with its parts and filament assignments).

Input parameters:

- `filament` (integer)
- `name` (string)
- `path` (string, required)
- `plate` (integer)
- `rotate_z` (number)
- `scale` (number)
- `x`
- `y`

### `add_relief` (~254 tokens)

Text or an SVG logo on a face of an object, raised or engraved, like Bambu Studio's Text and SVG tools. It
wraps around curved faces: on a cup it keeps its size along the surface and stands out square to it.
face: top, bottom, front, back, left, right (the side it is read from); at: [x, y, z] plate point to center it
on (default: the middle of that face); size: capital letter height for text, longest side for an SVG (mm);
depth: how far it stands out or goes in; rotate: degrees within the face.
Raised, it is a new part (filament=N prints it in another color); engraved, a negative part (set_part_type
turns it back). Look at preview_plate afterwards.

Input parameters:

- `at`
- `depth` (number)
- `engrave` (boolean)
- `face` (string)
- `filament` (integer)
- `font` (string)
- `object` (string, required)
- `rotate` (number)
- `size` (number)
- `svg` (string)
- `text` (string)

### `add_shape` (~305 tokens)

Create a simple solid: box (width, depth, height), cylinder (diameter, height), cone (diameter,
diameter_top, height), sphere (diameter), text (text, text_height = capital letters in mm, height = depth
of the letters; base > 0 puts the text on a plate that thick, as a separate part 'Base' with filament
base_filament (0 = same as the text), e.g. white letters on a black tag; font = path to a .ttf/.otf),
svg (svg = path of an .svg file, a logo raised `height` mm; size = its longest side in mm, 0 = the file's
own size; base works as for text). To put text or a logo on an existing object, use add_relief.

Input parameters:

- `base` (number)
- `base_filament` (integer)
- `depth` (number)
- `diameter` (number)
- `diameter_top` (number)
- `filament` (integer)
- `font` (string)
- `height` (number)
- `name` (string)
- `plate` (integer)
- `shape` (string, required)
- `size` (number)
- `svg` (string)
- `text` (string)
- `text_height` (number)
- `width` (number)
- `x`
- `y`

### `move_object` (~102 tokens)

Move an object (by name or id): absolute x/y, relative dx/dy, rotate around Z by rotate_z degrees,
or move it to another plate (it keeps x/y if given, otherwise it goes to a free spot).

Input parameters:

- `dx` (number)
- `dy` (number)
- `object` (string, required)
- `plate` (integer)
- `rotate_z` (number)
- `x`
- `y`

### `transform_object` (~73 tokens)

Scale (uniform or per axis) and rotate an object around its center. It stays on the bed.

Input parameters:

- `object` (string, required)
- `rotate_x` (number)
- `rotate_y` (number)
- `rotate_z` (number)
- `scale` (number)
- `scale_xyz`

### `duplicate_object` (~49 tokens)

Copy an object `copies` times onto free spots (same plate unless `plate` is given).

Input parameters:

- `copies` (integer)
- `object` (string, required)
- `plate` (integer)

### `fill_plate` (~148 tokens)

Fill the free area of an object's plate with copies of it, like Bambu Studio's Fill bed with copies.
copies: 0 = as many as fit, N = at most N. Shapes nest by their real outline (brim and brim ears counted), and
rotate=True also tries turning them by rotation_step degrees. The original is placed again together with the
copies (more fit), unless keep_original=True; the other objects on the plate stay where they are.

Input parameters:

- `copies` (integer)
- `gap` (number)
- `keep_original` (boolean)
- `object` (string, required)
- `rotate` (boolean)
- `rotation_step` (number)

### `convert_units` (~110 tokens)

An object modeled in other units, like Bambu Studio's Convert from inch / meter: unit 'inch', 'cm' or
'meter' scales it up from that unit to millimeters (a 1-unit cube becomes 25.4, 10 or 1000 mm);
restore=True scales it back down. import_model says when a model looks like it is in inches or meters.

Input parameters:

- `object` (string, required)
- `restore` (boolean)
- `unit` (string)

### `set_object_printable` (~66 tokens)

Keep an object on the plate but leave it out of the print (printable=False), like unticking Printable in
Bambu Studio; True puts it back. The other objects slice and print as usual.

Input parameters:

- `object` (string, required)
- `printable` (boolean)

### `copy_object_settings` (~103 tokens)

Copy one object's own settings (set_object_setting: infill, walls, brim...) to other objects, like Bambu
Studio's Copy / Paste process settings. keys: only these; replace=True first removes the targets' own
settings; height_ranges=True copies the height bands too.

Input parameters:

- `from_object` (string, required)
- `height_ranges` (boolean)
- `keys`
- `replace` (boolean)
- `to_objects` (array, required)

### `align_objects` (~99 tokens)

Line up objects of one plate, like Bambu Studio's Align / Distribute, by their outer boxes.
align: left, right, center_x (along X); front, back, center_y (along Y). distribute: 'x' or 'y' spaces them
evenly between the two outermost ones. Both can be given.

Input parameters:

- `align` (string)
- `distribute` (string)
- `objects` (array, required)

### `export_stl` (~109 tokens)

Save objects as STL files (e.g. to print them on other printers of a farm, or to share them): the named
objects, all of a plate, or all of the project. One file per object, or one_file=True for all of them where
they are on the plate. Negative parts (holes) are cut out; colors and settings are not part of an STL.

Input parameters:

- `objects`
- `one_file` (boolean)
- `plate` (integer)

### `replace_with_stl` (~124 tokens)

Swap the shape of an object (or of its part `part`) for the one in an STL/OBJ/3MF file, like Bambu
Studio's Replace with STL, e.g. after fixing it in CAD. Name, filament, settings, place on the plate and the
other parts stay; the new shape takes the old one's center, standing on the same bottom. Painting on the old
shape is dropped (it was for other triangles).

Input parameters:

- `object` (string, required)
- `part` (string)
- `path` (string, required)

### `delete_object` (~22 tokens)

Remove an object from the project.

Input parameters:

- `object` (string, required)

### `set_object_filament` (~51 tokens)

Assign a filament slot to a whole object, or to one of its parts (by part name).

Input parameters:

- `filament` (integer, required)
- `object` (string, required)
- `part` (string)

### `set_object_setting` (~65 tokens)

Per-object print setting (e.g. sparse_infill_density '40%', wall_loops '4', layer_height '0.12').
An empty value removes the override.

Input parameters:

- `key` (string, required)
- `object` (string, required)
- `value` (string, required)

### `check_object` (~33 tokens)

Is the mesh a closed, printable solid? Size, volume, number of separate pieces.

Input parameters:

- `object` (string, required)

### `measure_object` (~166 tokens)

Measure an object (or its part `part`), in plate mm: size and where it is, each part's size, volume and
surface, the area standing on the bed, the smallest gaps between its separate pieces or parts (the clearance of
print-in-place joints, with where), and walls thinner than the nozzle's line width (or min_wall mm), with
where and at which heights. z >= 0: also the cross-section at that height above the bed, every island with
its length, width and thickest point and its holes (how long and thick a bar is, how wide a hole is).

Input parameters:

- `min_wall` (number)
- `object` (string, required)
- `part` (string)
- `z` (number)

### `measure_between` (~119 tokens)

Distance between two objects or two parts (part_a / part_b; the same object twice with two parts measures
the clearance between them), in plate mm: the smallest gap with about where it is, the distance between their
centers, the gap along each axis between their outer boxes (negative = they overlap along it) and, if they
overlap, the volume they share.

Input parameters:

- `object_a` (string, required)
- `object_b` (string, required)
- `part_a` (string)
- `part_b` (string)

### `arrange` (~318 tokens)

Arrange objects by their real outline seen from above, brim and brim ears included, so shapes can nest
(like Bambu Studio's Arrange, which only uses convex hulls). gap: mm between those outlines (and from the
plate's edge half of it). Which objects: plate N, the named `objects` (ids or names), or all (plate=0).
plates: 0 = each object stays on its plate; N = spread them over plates 1..N, evenly; -1 = as few plates as
possible. rotate: allow turning them by multiples of rotation_step degrees (e.g. 60 for snowflakes);
multi_material false = one material (set of filaments) per plate; avoid_calibration_area: keep off the
printer's flow calibration corner (P1S/X1: front left); align_to_y: long side along Y first.
Plates with more than one material keep the back right corner free for the prime tower.
If something does not fit, nothing is moved: the answer says what is left over and how many plates it needs.
Objects not being arranged stay where they are. Look at preview_plate(view='top') afterwards.

Input parameters:

- `align_to_y` (boolean)
- `avoid_calibration_area` (boolean)
- `gap` (number)
- `multi_material` (boolean)
- `objects`
- `plate` (integer)
- `plates` (integer)
- `rotate` (boolean)
- `rotation_step` (number)

### `get_setting` (~37 tokens)

Current value of a print/filament/printer setting, where it comes from, and the preset value.

Input parameters:

- `key` (string, required)

### `set_setting` (~167 tokens)

Override a project setting. For filament settings (temperatures, plate temperatures...) slot = filament
slot (0 = all slots). Values are Bambu Studio strings, e.g. '0.16', '15%', '65'. Useful keys:
layer_height, wall_loops, sparse_infill_density, top_shell_layers, enable_support, brim_type,
initial_layer_speed, ironing_type, textured_plate_temp(_initial_layer) for Textured PEI,
hot_plate_temp(_initial_layer) for the smooth/High Temp plate, nozzle_temperature(_initial_layer),
close_fan_the_first_x_layers, print_sequence ('by object'), curr_bed_type ('Textured PEI Plate').

Input parameters:

- `key` (string, required)
- `slot` (integer)
- `value` (string, required)

### `reset_setting` (~28 tokens)

Drop an override: the setting goes back to the preset value.

Input parameters:

- `key` (string, required)

### `get_purge_volumes` (~55 tokens)

Purge (flush) volumes between filament slots, in mm³, and the multiplier: the filament wasted at each
change on the prime tower (or into infill/objects, see set_purge_volumes).

### `set_purge_volumes` (~216 tokens)

Change the purge (flush) volumes, as in Bambu Studio's Purging volumes dialog.
volumes: [{"from": 1, "to": 2, "volume": 350}, ...] mm³ for single changes; matrix: every value at once,
rows = from, columns = to (the diagonal is ignored); multiplier: scales all of them (0..3, 1 = as written);
reset: back to the values estimated from the colors and multiplier 1. A value set by hand stays while both
slots keep their color. Values are 0..900 mm³. Less purge saves filament but the new color can come out mixed
at first; to waste less without that, purge into the infill or into an object with
set_setting('flush_into_infill', '1') or set_object_setting(object, 'flush_into_objects', '1').

Input parameters:

- `matrix`
- `multiplier` (number)
- `reset` (boolean)
- `volumes`

### `save_project` (~77 tokens)

Write the project as a Bambu Studio .3mf (default folder: the output dir, name from the project).
Never overwrites: if the file exists a -2, -3... suffix is added. Optionally open it in Bambu Studio.

Input parameters:

- `open_in_bambu` (boolean)
- `path` (string)

### `open_in_bambu_studio` (~91 tokens)

Open a .3mf in the Bambu Studio window: by default the last saved project (else the last sliced one).
Bambu Studio re-slices a project when asked (Slice plate), it does not reuse the slicing done here; to open
a plate sliced and ready to print, use send_to_printer(via='bambu_studio').

Input parameters:

- `path` (string)

### `slice_project` (~69 tokens)

Slice with Bambu Studio (plate 0 = all). Returns per plate: minutes, grams (total and per filament slot),
cost (from the presets' price per kg), filament changes, layers and warnings. The sliced project is saved next to the project file.

Input parameters:

- `plate` (integer)

### `preview_plate` (~119 tokens)

Image of a plate with its objects in their filament colors (painted colors too).
view: iso | top. zoom: frame the objects instead of the whole bed, to see details.
labels: write each object's id and name on it, e.g. view='top', labels=True to tell which part is which
(a part that came off the plate, the list in Bambu Handy's skip objects).

Input parameters:

- `labels` (boolean)
- `plate` (integer)
- `view` (string)
- `zoom` (boolean)

### `check_print_risks` (~130 tokens)

Before a long print: parts likely to come off or topple, and settings that do not fit. Per plate (0 = all):
tall and narrow parts (height against the smaller side of the footprint), parts standing on a narrow or tiny
footing without a brim (e.g. pins lying on their side), filaments whose temperature for this build plate is 0
(not meant for it), and plates where tall parts share a long print with many others (a part that fails late can
knock the others: print them apart).

Input parameters:

- `plate` (integer)

### `reprint_objects` (~134 tokens)

A new project with only some objects of the open one, e.g. a part that came off the plate and was skipped:
same printer, process, filaments and settings, laid out again (more plates if needed); brim=True gives each
an outer brim. Saved as a new file (never overwrites) and sliced; the open project is not changed:
open_project(file) then send_to_printer to print it. objects: names or ids (see get_project).

Input parameters:

- `brim` (boolean)
- `name` (string)
- `objects` (array, required)
- `slice` (boolean)

### `preview_layer` (~92 tokens)

Image of one sliced layer seen from the top (needs slice_project first). Choose by layer number (1 = first)
or by height z in mm. Extrusions are drawn in the filament colors. zoom: frame the extrusions (default),
or False for the whole bed.

Input parameters:

- `layer` (integer)
- `plate` (integer)
- `z` (number)
- `zoom` (boolean)

### `make_first_layer_test` (~81 tokens)

Add a plate with the first `height` mm of the objects of a plate (or of the listed objects):
a short print to check bed adhesion and the first layers before a long print. Slice it with
slice_project(plate=<new plate>).

Input parameters:

- `height` (number)
- `objects`
- `plate` (integer)

### `send_to_printer` (~288 tokens)

Make the print file of one plate (.gcode.3mf) and send it.
via = auto (Bambu Connect if installed, otherwise Bambu Studio) | bambu_connect | bambu_studio: open it in an
  official Bambu app, where the user checks printer and AMS mapping and presses Print/Send.
via = file: only make the file.
via = lan: copy it to the printer on the local network and START PRINTING, for printers in LAN-only mode with
  Developer Mode (print farms; in cloud mode the printer refuses and the answer says so). Two steps: without
  confirm nothing is sent, the answer gives the AMS slots it would use and a code; check with the user that the
  plate is clear, then call again with confirm=<code>. AMS slots: from use_ams_filaments, or ams_slots (one AMS
  slot per project filament slot, 0 = automatic), or the tray with the same type and the closest color.
Tell the user the time, weight and filaments of the plate (and for lan, follow it with printer_status).

Input parameters:

- `ams_slots`
- `bed_leveling` (boolean)
- `confirm` (string)
- `plate` (integer)
- `timelapse` (boolean)
- `via` (string)

### `skip_objects` (~159 tokens)

Stop printing some objects of the print running now, e.g. a part that came off the plate. It CANNOT be undone.
ids: the objects' ids as the printer knows them (identify_id; Bambu Handy's skip list, or printer_status
'skipped_objects'). Do not list every object: to stop the whole print, cancel it on the printer.
First call without confirm: nothing is sent, the answer says what would be skipped and the confirm code; tell
the user, and only after they agree call again with confirm=<code>.
Bambu firmware accepts it only in LAN-only mode with Developer Mode; otherwise use Bambu Handy or the printer.

Input parameters:

- `confirm` (string)
- `ids` (array, required)

### `ams_load` (~174 tokens)

Load the filament of an AMS slot into the nozzle, like Load in Bambu Studio's Device tab: the nozzle heats,
the filament loaded now (if any) goes back to its slot, the new one comes in and is purged. slot: as in
printer_status (AMS 1 = slots 1-4, AMS 2 = 5-8). Only when the printer is not printing.
First call without confirm: nothing is sent, the answer says what would happen and the confirm code; tell the
user, and only after they agree call again with confirm=<code>.
Bambu firmware accepts it only in LAN-only mode with Developer Mode; otherwise use the printer screen, Bambu
Handy or Bambu Studio.

Input parameters:

- `confirm` (string)
- `slot` (integer, required)

### `ams_unload` (~115 tokens)

Unload the filament in the nozzle back to its AMS slot, like Unload in Bambu Studio's Device tab (the nozzle
heats). Only when the printer is not printing. First call without confirm: nothing is sent, the answer gives
the confirm code; call again with confirm=<code> only after the user agrees.
Bambu firmware accepts it only in LAN-only mode with Developer Mode; otherwise use the printer screen, Bambu
Handy or Bambu Studio.

Input parameters:

- `confirm` (string)

### `printer_status` (~177 tokens)

Read-only status of the printer on the local network: state, job, progress, remaining time, layer
(or the last job's result when idle), temperatures, AMS trays (type, color, remaining %; 'unknown' = a spool
the AMS has not been told about), AMS humidity and temperature, active slot, errors, objects skipped during the
print, and warnings (the spool being fed is unknown or not the project's filament, sport speed on a long print,
a report that looks old). read_at = when the printer sent it; age_s = seconds since, when a reading of a few
seconds ago is given again (the printer is asked at most every 20 s).
Works with the printer in normal cloud mode (Bambu Handy keeps working). Nothing is sent to the printer except a
status request.

### `printer_camera` (~89 tokens)

A picture from the printer's camera right now (P1 and A1 series), to see the plate: how a print is going,
whether something came off or made spaghetti, what is left on the bed. Read-only; works with the printer in
cloud mode. With the chamber light off the picture is dark. max_size: longest side in pixels.

Input parameters:

- `max_size` (integer)

### `printer_files` (~88 tokens)

Files on the printer's SD card, newest first, with name, size and date and the total per folder:
timelapse (videos of past prints), prints (files of past prints the printer keeps), thumbnails (timelapse
thumbnails whose video was deleted). Read-only; works with the printer in cloud mode.

Input parameters:

- `kind` (string)
- `limit` (integer)

### `download_printer_file` (~88 tokens)

Copy a file from the printer's SD card into the projects folder: a timelapse video (name from printer_files,
or 'latest') or the file of a past print (kind='prints'). For a timelapse its last frame is shown too: the
finished print. Read-only on the printer.

Input parameters:

- `kind` (string)
- `name` (string)

### `delete_printer_files` (~154 tokens)

Free space on the printer's SD card: delete timelapse videos (with their thumbnails), files of past prints
(kind='prints') or thumbnails whose video is gone (kind='thumbnails'). Pick them by names (from printer_files)
or all those older than older_than_days. Two steps: without confirm nothing is deleted, the answer lists what
would go, the space freed and a code; show the list to the user and only if they agree call again with
confirm=<code>. Deleted files cannot be recovered. Nothing is deleted while a print is running.

Input parameters:

- `confirm` (string)
- `kind` (string, required)
- `names`
- `older_than_days` (integer)

### `use_ams_filaments` (~101 tokens)

Set the project's filament slots from what is loaded in the AMS right now (preset and color), like
Bambu Studio's 'sync AMS'. Default: every loaded tray in order (project slot 1 = first loaded tray).
ams_slots: pick trays explicitly, e.g. [1, 3] -> project slot 1 = AMS slot 1, project slot 2 = AMS slot 3.

Input parameters:

- `ams_slots`

### `add_layer_action` (~142 tokens)

Do something when the print reaches height z (mm), before that layer is printed:
action = pause (e.g. to insert magnets or nuts; message is shown in Bambu Studio),
filament_change (switch to filament slot `filament` from that height on, with the AMS),
gcode (any G-code line(s), e.g. 'M104 S210'). z is snapped to the nearest real layer at or above it.

Input parameters:

- `action` (string, required)
- `filament` (integer)
- `gcode` (string)
- `message` (string)
- `plate` (integer, required)
- `z` (number, required)

### `remove_layer_action` (~46 tokens)

Remove a layer action (1-based index as listed by get_project), or all of them with index 0.

Input parameters:

- `index` (integer)
- `plate` (integer, required)

### `make_temperature_tower` (~113 tokens)

Add a plate with a temperature tower for a filament slot: one 8 mm block per temperature (hottest at the
bottom), each with a bridge and its temperature engraved on the front. Defaults: the filament's
temperature +15 down to -25 °C, within its allowed range. Pick the block with the best bridge, surface and
least stringing.

Input parameters:

- `end` (number)
- `filament` (integer)
- `start` (number)
- `step` (number)

### `make_flow_test` (~116 tokens)

Add a plate of flow-rate squares for a filament slot, each printed with a different flow modifier (percent)
engraved on top. Pass 1: -20..+20 step 5. Pass 2: around the best one, e.g. low=-4 high=4 step=1.
Pick the square with the smoothest top surface (no gaps, no ridges).

Input parameters:

- `filament` (integer)
- `high` (number)
- `low` (number)
- `step` (number)

### `make_pa_tower` (~107 tokens)

Add a plate with a pressure advance (flow dynamics) tower: a thin square tube printed fast, the K value grows
by `step` every millimeter. Find the height with the sharpest corners and no gaps: K = start + floor(height) * step.
When sending it, turn off the printer's automatic flow dynamics calibration.

Input parameters:

- `end` (number)
- `filament` (integer)
- `start` (number)
- `step` (number)

### `make_vfa_test` (~128 tokens)

Add a plate with a VFA test (vertical fine artifacts: fine vertical ripples on walls that some speeds cause):
one block per outer wall speed from start to end mm/s, the speed engraved on top. Look at the long faces with
light from the side and pick the fastest speed without ripples for outer_wall_speed. Bambu Studio's VFA tower
changes the speed inside one object; here each block has its own speed.

Input parameters:

- `end` (number)
- `filament` (integer)
- `start` (number)
- `step` (number)

### `save_filament_preset` (~196 tokens)

Save the filament of a slot, with this project's changes for that slot (temperatures, flow ratio, pressure
advance, plate temperatures...), as a Bambu Studio user preset; it appears after Bambu Studio restarts.
A new filament (made from a Generic preset, or with another filament_vendor) is saved like Bambu Studio's
Create Filament does: its own filament id, so it can be picked for an AMS slot (Device > AMS). Changes to a
Bambu filament are saved as a variant of it, so its RFID spools still match it.
replace=True updates an existing user preset with that name (e.g. after a calibration): it keeps its
filament id, so AMS slots set to it stay valid, and a backup copy is kept. Never overwrites otherwise.

Input parameters:

- `name` (string, required)
- `replace` (boolean)
- `slot` (integer, required)

### `save_process_preset` (~109 tokens)

Save this project's process changes (layer height, walls, infill, speeds, brim, supports, ironing...:
the set_setting changes that belong to the process) as a Bambu Studio user process preset, a child of the
project's process preset, like Save as in Bambu Studio. replace=True updates your user preset with that name
(a backup copy is kept). It appears after Bambu Studio restarts.

Input parameters:

- `name` (string, required)
- `replace` (boolean)

### `save_printer_preset` (~98 tokens)

Save this project's printer changes (start/end G-code, retraction, printable area...: the set_setting
changes that belong to the printer) as a Bambu Studio user printer preset, a child of the project's printer
preset. replace=True updates your user preset with that name (a backup copy is kept). It appears after
Bambu Studio restarts.

Input parameters:

- `name` (string, required)
- `replace` (boolean)

### `list_user_presets` (~85 tokens)

Your own Bambu Studio presets (kind: filament | process | printer; empty = all): the preset each one
inherits and what it changes, whether it is in your Bambu cloud (then only Bambu Studio can delete or
rename it), and which presets inherit it. To find system presets too, use search_presets.

Input parameters:

- `kind` (string)

### `edit_preset` (~171 tokens)

Change settings of one of your user presets directly, without a project (a backup copy is kept).
kind: filament | process | printer. values: {"key": "value"}, e.g. {"pressure_advance": "0.025",
"enable_pressure_advance": "1"} or {"nozzle_temperature": "215"}; a list gives one value per extruder variant
(Standard / High Flow nozzle); null removes the key, so the value comes from the parent preset again.
Bambu system presets are read-only: save a user preset from them first. Bambu Studio sees the change after it
restarts, and uploads it to your Bambu cloud if the preset is there.

Input parameters:

- `kind` (string, required)
- `name` (string, required)
- `values` (object, required)

### `rename_preset` (~82 tokens)

Rename one of your user presets (a backup copy is kept). A preset in your Bambu cloud cannot be renamed
from here, because Bambu Studio would download the old one again: the answer says how to do it in Bambu
Studio.

Input parameters:

- `kind` (string, required)
- `name` (string, required)
- `new_name` (string, required)

### `delete_preset` (~85 tokens)

Delete one of your user presets (a backup copy is kept, see the answer). A preset in your Bambu cloud
cannot be deleted from here, because Bambu Studio would download it again at its next start: only its own
Delete removes the cloud copy, and the answer says where it is.

Input parameters:

- `kind` (string, required)
- `name` (string, required)

### `sync_with_bambu_studio` (~73 tokens)

Re-read the project file after you changed it by hand in Bambu Studio and saved (same file).
This also happens automatically on the next command when there are no unsaved changes here;
force=True takes the app's version even if there are (they are lost).

Input parameters:

- `force` (boolean)

### `mirror_object` (~37 tokens)

Mirror an object across its own center (axis x, y or z).

Input parameters:

- `axis` (string)
- `object` (string, required)

### `lay_flat` (~55 tokens)

Rotate an object so one of its flat faces lies on the bed: face 1 = the biggest flat face,
2 = the second biggest, and so on.

Input parameters:

- `face` (integer)
- `object` (string, required)

### `orient_object` (~125 tokens)

Turn an object the way up it prints best, like Bambu Studio's Auto orientation: least area that needs support
(faces leaning more than overhang_angle degrees from vertical, not on the bed), enough area on the bed, low
height. Returns the 3 best options with those numbers and the current ones; choice=2 or 3 applies another
option, apply=False only compares. Look at preview_plate afterwards.

Input parameters:

- `apply` (boolean)
- `choice` (integer)
- `object` (string, required)
- `overhang_angle` (number)

### `split_object` (~105 tokens)

Split an object into its separate pieces, like Bambu Studio's Split: into='objects' makes one object per
piece (each part of a multi-part object becomes an object too), into='parts' keeps one object whose parts are
the pieces, so each can get its own filament. Pieces stay where they are; painted colors are kept, modifiers
and negative parts go with the piece they overlap.

Input parameters:

- `into` (string)
- `object` (string, required)

### `merge_objects` (~95 tokens)

Join objects of the same plate into one object with several parts, where they are now, like Bambu Studio's
Assemble: they move and print as one (e.g. a model and its base in another color). Each part keeps its filament
and painting; the merged object takes the first object's settings (the others' are listed if they differ).

Input parameters:

- `name` (string)
- `objects` (array, required)

### `boolean_objects` (~157 tokens)

Mesh boolean between two objects where they are on the plate, like Bambu Studio's Mesh boolean.
difference: cut tool_object's shape out of object (a hole, a slot, a lettering); intersection: keep only what
they share; union: weld tool_object onto object (onto its part `part`, default the biggest). The result keeps
object's name, settings and filaments; painted colors stay, new faces take the part's filament. The tool object
is removed unless keep_tool=True. Both must be closed solids (check_object).

Input parameters:

- `keep_tool` (boolean)
- `object` (string, required)
- `operation` (string)
- `part` (string)
- `tool_object` (string, required)

### `cut_object` (~504 tokens)

Cut an object with a plane, optionally with connectors that line the pieces up for gluing (like the
connectors of Bambu Studio's Cut tool). keep: both | bottom | top.
The plane is horizontal at height z (mm from the object's bottom), or goes through `point` [x, y, z] (plate mm,
z above the bed) with `normal` [nx, ny, nz]: [1, 0, 0] cuts vertically across x, [0.5, 0, 1] is tilted.
place: auto = the lower piece stays as it is and the upper one lies on its cut face; cut_down = both lie on their
cut faces; keep = both as they were.
connector: none | plug (a peg on the piece whose cut face is up, a hole with `clearance` mm per side in the
other) | dowel (holes in both pieces and a separate pin, added to the plate) | dovetail (a tongue across the
whole cut, along its length, and a slot in the other piece: they slide together from the side).
shape: cylinder | square | hexagon; style: prism | frustum (tapered, centers itself); size: diameter or side in
mm, or the dovetail's narrow width (0 = from the cut); depth: peg, pin or dovetail height (0 = automatic);
count: 0 = one per piece of the cut (two along a long one), N = spread over the cut; positions: [[x, y], ...] or
[[x, y, z]] in plate mm, taken on the plane (for a dovetail: a point on its middle line). Holes keep 2 mm of material from the
edge and get shallower where a piece is thin; connectors that do not fit are listed as skipped.
Modifiers, negative parts and painted colors are kept on the pieces.

Input parameters:

- `clearance` (number)
- `connector` (string)
- `count` (integer)
- `depth` (number)
- `keep` (string)
- `normal`
- `object` (string, required)
- `place` (string)
- `point`
- `positions`
- `shape` (string)
- `size` (number)
- `style` (string)
- `z` (number)

### `set_part_type` (~96 tokens)

Change what a part of an object is, like Bambu Studio's Change type: 'part' (printed), 'modifier' (its
settings apply inside it), 'negative' (cut out, a hole), 'support_blocker' or 'support_enforcer'. An object
keeps at least one printed part.

Input parameters:

- `object` (string, required)
- `part` (string, required)
- `type` (string, required)

### `add_modifier` (~215 tokens)

Add a part to an object, covering its whole footprint between z_from and z_to (mm from the
object's bottom; z_to 0 = top), or only region [x0, y0, x1, y1] (mm from the object's center).
kind: modifier (different settings inside, e.g. {"sparse_infill_density": "100%"} for the top 5 mm),
negative (removes material), support_blocker, support_enforcer.
shape: box, or cylinder (round, as wide as the smaller side of the region: e.g. a hole for a magnet or a
screw is kind='negative', shape='cylinder', region=[-4, -4, 4, 4] for 8 mm).

Input parameters:

- `kind` (string)
- `object` (string, required)
- `region`
- `settings`
- `shape` (string)
- `z_from` (number)
- `z_to` (number)

### `remove_part` (~48 tokens)

Remove a part (e.g. a modifier) from an object, by part name. The last solid part cannot be removed.

Input parameters:

- `object` (string, required)
- `part` (string, required)

### `add_brim_ears` (~295 tokens)

Brim ears: small round brims only where a part needs them, instead of a brim all around (Bambu Studio's
Painted brim). Meant for print-in-place and articulated models: a full brim fills the joint gaps on the first
layer and welds them. Without points, ears go to the tips of the thin parts of the first layer (fingers, toes,
any tip thinner than `narrow` mm), each as large as possible up to `radius` without reaching another piece, a
gap or hole, or a second thin part (those tips are listed as skipped, with the reason). small > 0 also gives
ears to first-layer pieces smaller than that (mm²), at their ends. points: [[x, y], ...] or [[x, y, radius]]
in plate mm, placed as given, with a warning when one would weld something. radius 0 = Bambu Studio's default
(16 first-layer line widths across). keep: add to the ears the object already has.
Look at them with preview_plate(view='top', zoom=True), then slice_project and preview_layer(layer=1).

Input parameters:

- `clearance` (number)
- `keep` (boolean)
- `narrow` (number)
- `object` (string, required)
- `points`
- `radius` (number)
- `small` (number)

### `remove_brim_ears` (~34 tokens)

Remove an object's brim ears; its brim goes back to the project's brim type.

Input parameters:

- `object` (string, required)

### `set_height_range` (~153 tokens)

Settings for a height band of an object, like Bambu Studio's Height range modifier. Heights are mm from the
object's bottom. E.g. z_from=0, z_to=5, settings={"sparse_infill_density": "100%"}; {"layer_height": "0.12"}
for finer layers there (variable layer height); {"filament": 2} to print that band with another filament slot
(a color band). A band with the same z_from and z_to is updated (null removes a key); bands cannot overlap.

Input parameters:

- `object` (string, required)
- `settings` (object, required)
- `z_from` (number, required)
- `z_to` (number, required)

### `remove_height_range` (~49 tokens)

Remove the height band of an object that starts at z_from (mm), or all its bands (z_from=-1).

Input parameters:

- `object` (string, required)
- `z_from` (number)

### `paint_object` (~248 tokens)

Paint a region of an object, like Bambu Studio's painting tools. paint: 'color' (with filament=N),
'support' (supports there), 'block_support' (none there), 'seam' (put the seam there), 'block_seam',
'fuzzy_skin'. Region: the height band z_from..z_to (mm from the object's bottom; z_to=0 = to the top) and the
faces looking 'top', 'bottom', 'sides', 'front', 'back', 'left', 'right', 'overhangs' (leaning more than `angle`
degrees from vertical, for supports) or 'all'. clear=True removes that painting there. Triangles crossing a
band's edge are split, so the edge is sharp. part: only that part. Look at preview_plate (colors) afterwards.

Input parameters:

- `angle` (number)
- `clear` (boolean)
- `facing` (string)
- `filament` (integer)
- `object` (string, required)
- `paint` (string, required)
- `part` (string)
- `z_from` (number)
- `z_to` (number)

### `make_max_flow_test` (~126 tokens)

Max volumetric speed test for a filament slot, as a separate project file (the open project is not changed):
single-wall cylinders, each printed at the wall speed that gives the volumetric speed Q (mm³/s) on its tag.
Default range: around the filament's current limit. The highest Q without gaps or weak walls is the max;
use a bit less (about 90%) as filament_max_volumetric_speed.

Input parameters:

- `filament` (integer)
- `high` (number)
- `low` (number)
- `step` (number)

### `make_retraction_test` (~91 tokens)

Stringing test for a filament slot: one small separate project per retraction length (Bambu printers cannot
change retraction during a print). Print them one after the other and keep the shortest length without strings
between the two pillars; then set_setting('filament_retraction_length', value, slot) or save_filament_preset.

Input parameters:

- `filament` (integer)
- `lengths`

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/danielefinocchiaro-unofficial-bambu-mcp/unofficial-bambu-mcp#diagnostics

## Score history

- 2026-11-04: 53
- 2026-11-03: 64
- 2026-11-02: 64
- 2026-11-01: 64
- 2026-10-31: 64
- 2026-10-30: 64
- 2026-10-29: 49
- 2026-10-28: 49

## Common questions

### What is the Bambu Studio (unofficial) MCP server?

Bambu Studio (unofficial) is an MCP server listed in the public MCP registry as io.github.danielefinocchiaro/unofficial-bambu-mcp. Build, edit, slice, check and calibrate Bambu Studio projects; read a Bambu Lab printer's status. This page covers its PyPI package (unofficial-bambu-mcp).

### Is the Bambu Studio (unofficial) MCP server safe to use?

Bambu Studio (unofficial) scores 53 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 4 November 2026. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Bambu Studio (unofficial) MCP server expose?

Bambu Studio (unofficial) exposes 87 tools: bambu_status, list_printers, search_presets, filament_colors, new_project, and 82 more. Their descriptions and schemas cost roughly 10,007 tokens of context every time the server is loaded.

### Is the Bambu Studio (unofficial) MCP server still maintained?

Bambu Studio (unofficial) is still listed as active in the MCP registry. We last reached this channel on 4 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Bambu Studio (unofficial) MCP server under?

Bambu Studio (unofficial) declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/unofficial-bambu-mcp/
- Socket report: https://socket.dev/pypi/package/unofficial-bambu-mcp
- Repository: https://github.com/danielefinocchiaro/unofficial-bambu-mcp
- Changelog RSS feed: https://verifymcp.io/servers/danielefinocchiaro-unofficial-bambu-mcp/unofficial-bambu-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/danielefinocchiaro-unofficial-bambu-mcp/unofficial-bambu-mcp.json
- HTML version of this page: https://verifymcp.io/servers/danielefinocchiaro-unofficial-bambu-mcp/unofficial-bambu-mcp