# Slicewise (npm · @gjlmotea/slicewise-mcp)

Pre-print checks for Bambu Studio: GUI-faithful CLI slicing, override audit, printability.

- Trust score: 71/100 (medium)
- Change this week: 0
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- npm · `@gjlmotea/slicewise-mcp`: 71/100 (this document), [markdown](https://verifymcp.io/servers/gjlmotea-slicewise-for-bambu-studio-mcp/gjlmotea-slicewise-mcp.md), [page](https://verifymcp.io/servers/gjlmotea-slicewise-for-bambu-studio-mcp/gjlmotea-slicewise-mcp)

## Channel facts

- Registry: `npm`
- Package: `@gjlmotea/slicewise-mcp`
- Version: `0.1.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-21.

- **Supply Chain Security**: 81/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known high-severity CVE affects zod 3.25.76, a direct dependency. A fixed version is available.
  - No install/post-install scripts declared.
  - 31 of 93 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to gjlmotea/slicewise-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 13 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 59/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3289 tokens (~205/item across 16 items; 16 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 88/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 60% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 16 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 17 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Slicewise MCP server?

Slicewise runs locally as an npm package, launched with npx -y @gjlmotea/slicewise-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 gjlmotea-slicewise-for-bambu-studio-mcp -- npx -y @gjlmotea/slicewise-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "gjlmotea-slicewise-for-bambu-studio-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@gjlmotea/slicewise-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "gjlmotea-slicewise-for-bambu-studio-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@gjlmotea/slicewise-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add gjlmotea-slicewise-for-bambu-studio-mcp -- npx -y @gjlmotea/slicewise-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "gjlmotea-slicewise-for-bambu-studio-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@gjlmotea/slicewise-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add gjlmotea-slicewise-for-bambu-studio-mcp --command npx --arg -y --arg @gjlmotea/slicewise-mcp
```

### Hermes

```yaml
mcp_servers:
  gjlmotea-slicewise-for-bambu-studio-mcp:
    command: "npx"
    args: ["-y", "@gjlmotea/slicewise-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "gjlmotea-slicewise-for-bambu-studio-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@gjlmotea/slicewise-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add gjlmotea-slicewise-for-bambu-studio-mcp -t stdio -c npx -a -y @gjlmotea/slicewise-mcp
```

### Other

```json
{
  "mcpServers": {
    "gjlmotea-slicewise-for-bambu-studio-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@gjlmotea/slicewise-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-08 (score 71)

First indexed and scored.

## MCP tools (16)

### `bambu_get_status` (~71 tokens)

Get Bambu Studio companion status

Reports the BambuStudio data directory, whether the slicer executable is available, preset counts, the machine and filaments currently selected in Studio, the allowed model directories, and the integration level of each model platform. Use it first to see what this server can do on this machine. No side effects.

Output parameters:

- `allowedModelRoots` (array)
- `catalogs` (array)
- `currentSelection` (object)
- `dataDir` (string)
- `inheritanceFlattening` (boolean)
- `outputConfigured` (boolean)
- `presetCounts` (object)
- `profileId` (string)
- `slicerAvailable` (boolean)
- `slicerPath` (string)
- `version` (string)

### `bambu_list_presets` (~139 tokens)

List presets

Lists machine, process or filament presets. By default only presets selectable in the UI are returned; intermediate presets that exist only to be inherited from (e.g. fdm_process_common) are filtered out. Names listed here do not show real setting values; use bambu_resolve_preset for that. No side effects.

Input parameters:

- `includeAbstract` (boolean): Whether to include intermediate presets that exist only to be inherited from and cannot be selected in the UI. Defaults to false.
- `kind` (string, required)
- `limit` (integer)
- `search` (string): Filter by a case-insensitive substring of the preset name.

Output parameters:

- `entries` (array)
- `kind` (string)
- `returned` (number)
- `total` (number)

### `bambu_resolve_preset` (~133 tokens)

Flatten a preset inheritance chain

Flattens a preset's inherits chain into the complete settings and records which level each value comes from. A BambuStudio leaf preset usually declares only a few dozen keys and inherits everything else from its parents, so to know the real value of any parameter you must look at the flattened result, not the leaf preset file. Use this whenever you need an actual setting value. No side effects.

Input parameters:

- `keys` (array): Return only these parameters. Omit to return all of them (a process preset has about 200 keys).
- `kind` (string, required)
- `name` (string, required)

Output parameters:

- `inheritanceChain` (array): The inheritance chain, from the leaf preset to the root.
- `kind` (string)
- `name` (string)
- `origin` (string)
- `provenance` (object): Which level of the inheritance chain each key actually comes from. Machine G-code may come from that level's template entry, named like "<preset> template machine_start_gcode".
- `settingCount` (number)
- `settings` (object)

### `bambu_compare_presets` (~93 tokens)

Compare two presets

Flattens two presets of the same kind and lists the settings that differ. Use it to answer questions like "what exactly is the difference between 0.20 Standard and 0.20 Strength" without reading four levels of JSON by hand. No side effects.

Input parameters:

- `kind` (string, required)
- `left` (string, required)
- `limit` (integer)
- `right` (string, required)

Output parameters:

- `differenceCount` (number)
- `differences` (array)
- `left` (string)
- `right` (string)

### `bambu_describe_parameters` (~71 tokens)

Explain parameters and their trade-offs

Explains what a parameter does, its unit, its typical range, the cost of raising or lowering it, and related parameters. Call this before changing any parameter, instead of tuning by what merely sounds reasonable. No side effects.

Input parameters:

- `group` (string)
- `keys` (array)

Output parameters:

- `specs` (array)
- `unknown` (array): Keys that are not in the parameter catalog.

### `bambu_diagnose` (~189 tokens)

Diagnose a print failure from its symptom

Takes an observed symptom (warping, stringing, layer separation, elephant's foot, holes in the top surface, ...) and returns an ordered list of remedies, each with its mechanism, a suggested value and its cost. Use it when the user describes what went wrong rather than which parameter to change; apply one remedy at a time. If no known symptom matches, it says so instead of guessing. It also points out problems that no parameter can fix. No side effects.

Input parameters:

- `material` (string): The material, e.g. PLA / ABS / PETG / TPU; a material-specific note is returned when one exists.
- `symptom` (string): The symptom in natural language, e.g. "the bottom layer bulges outward" (elephant's foot). Chinese descriptions are matched too.
- `symptomId` (string): A known symptom id; skips text matching.

Output parameters:

- `available` (array)
- `matched` (array)
- `note` (string)

### `bambu_plan_settings` (~318 tokens)

Plan settings for a goal

Given what you want (safe and failure-free / fast / strong under load / good surface / economical), returns ordered parameter adjustments grouped by what they counter: adhesion and warping, nozzle collisions, surface quality, structural strength, time, filament. Each move includes its mechanism, a suggested value, its cost, and **the actual value in the current preset and its shape** (per-extruder parameters must be overridden with an array; a scalar is silently not applied). If modelPath is given, a printability analysis runs first and conditional adjustments are added based on the geometry. This is for planning before a print; to work back from a print that already failed, use bambu_diagnose. It only returns a plan and changes nothing. No side effects.

Input parameters:

- `filamentPreset` (string)
- `goal` (string): What you want, in natural language, e.g. "don't let it fail, print slowly at high quality" or "in a hurry". Chinese goals are matched too.
- `goalId` (string): Specify the goal directly; skips text matching.
- `material` (string): PLA / PETG / ABS / ASA / TPU; a material-specific note is returned when one exists.
- `modelPath` (string): If a model is given, a printability analysis runs first and conditional adjustments are added based on the geometry (e.g. a wider brim when the base area is too small).
- `processPreset` (string): Defaults to the preset currently selected in Bambu Studio.

Output parameters:

- `available` (array)
- `goal` (object)
- `moves` (array)
- `note` (string)
- `printability` (object)

### `bambu_optimize_print_in_place` (~358 tokens)

Create a stabilised print-in-place preset

Creates an auto-stabilised copy of the given (or currently selected) process preset that can be used directly in Bambu Studio. Use it when small print-in-place parts detach from the bed or get dragged off by the nozzle. It applies exactly: first-layer outer wall 20 mm/s, first-layer infill 30 mm/s, outer wall capped at 60 mm/s, slowdown for overhangs, avoid crossing printed walls, Monotonic line, and ironing and Fuzzy Skin turned off. If the source is an existing user preset, its leaf-level calibrations (dimensions, elephant's foot, etc.) are kept, but the new file still inherits directly from the system preset. By default Auto Brim is explicitly turned off so the brim does not fuse gear clearances; Brim Ears can be requested explicitly, and you will still be reminded to check the first layer. It does not change filament temperature, cooling or flow, because regular PLA and Silk PLA must be calibrated separately. Writes a file to the user profile directory; takes effect after Bambu Studio is restarted.

Input parameters:

- `includeBrimEars` (boolean): Whether to also enable 5 mm Brim Ears. Defaults to false, because the moving clearances must be checked in the first-layer preview first.
- `name` (string): Name of the new user preset. Defaults to the source preset name with an auto-stabilised suffix appended.
- `overwrite` (boolean): Whether to replace a preset with the same name if one already exists. Defaults to false.
- `processPreset` (string): The source process preset; defaults to the one currently selected in Bambu Studio. An existing user preset may be given.

Output parameters:

- `basePreset` (string)
- `changes` (array)
- `created` (boolean)
- `manualActions` (array)
- `name` (string)
- `nextStep` (string)
- `overrides` (object): Parameters to override; each key is a BambuStudio setting name (e.g. layer_height, sparse_infill_density).
- `overwritten` (boolean)
- `path` (string)
- `preservedKeys` (array)
- `sourcePreset` (string)
- `warnings` (array)

### `bambu_save_user_preset` (~194 tokens)

Save a user preset to Bambu Studio

Creates a custom preset that inherits from a system preset, in the BambuStudio user profile directory; it appears in the dropdown after Bambu Studio is restarted. BambuStudio has no plugin API (see bambulab/BambuStudio#9614), so this is the only way to get parameters tuned by an AI into the GUI. Writes a file; an existing preset with the same name is never silently overwritten.

Input parameters:

- `inherits` (string, required): Name of the system (vendor) preset to inherit from.
- `kind` (string, required)
- `name` (string, required): Name of the new preset; it appears in the Bambu Studio dropdown.
- `overrides` (object, required): Parameters to override; each key is a BambuStudio setting name (e.g. layer_height, sparse_infill_density).
- `overwrite` (boolean): Whether to replace an existing preset with the same name. Defaults to false.

Output parameters:

- `created` (boolean)
- `nextStep` (string)
- `overwritten` (boolean)
- `path` (string)
- `warnings` (array)

### `bambu_slice` (~275 tokens)

Slice (after flattening the inheritance chain)

Slices with the BambuStudio CLI and reports real statistics: layer count, print time, filament weight. Presets are flattened before they are passed to the CLI; feeding the raw presets to the CLI makes every inherited parameter fall back to the built-in default (BambuStudio#1704), so do not call the CLI directly. After slicing, it reads the settings that actually took effect back from the output and audits each override you requested; an overrideAudit entry with honoured = false was not applied. Starts a child process and writes a .gcode.3mf to the configured output directory. It does not send anything to a printer or start a print.

Input parameters:

- `filamentPresets` (array)
- `machinePreset` (string)
- `modelPath` (string, required): Absolute path to the model file; it must be inside an allowed model directory.
- `overrides` (object): Parameters to override; each key is a BambuStudio setting name (e.g. layer_height, sparse_infill_density).
- `placement` (object)
- `plate` (integer)
- `processPreset` (string)
- `reportSettings` (array): Read back the values these parameters actually took in the output. Use it to confirm the slice really used the preset values rather than the slicer's built-in defaults.

Output parameters:

- `appliedSettings` (object): The actual values in the output of the parameters requested by reportSettings.
- `ok` (boolean)
- `outputPath` (string)
- `overrideAudit` (array)
- `reason` (string)
- `stats` (object)
- `stderrTail` (array)
- `warnings` (array)

### `bambu_inspect_model` (~123 tokens)

Inspect model geometry

Parses an STL (binary or ASCII), 3MF or OBJ and reports triangle count, bounding box, volume, surface area, and whether the mesh is closed. The format is detected from the file content, not the extension. For 3MF and OBJ it also reports the part count and part list (3MF coordinates have the placement transform applied; OBJ is split into parts by o / g, and Tinkercad's colour export is OBJ). Reads only files inside the allowed directories. No side effects.

Input parameters:

- `modelPath` (string, required)

Output parameters:

- `boundingBox` (object)
- `closed` (boolean)
- `degenerateTriangles` (number)
- `format` (string): The format actually detected, based on the content rather than the file extension.
- `openEdges` (number)
- `partCount` (number)
- `parts` (array)
- `surfaceAreaMm2` (number)
- `triangleCount` (number)
- `volumeMm3` (number)

### `bambu_check_printability` (~270 tokens)

Check printability

Finds problems visible before slicing: exceeding the build volume, floating bodies that do not touch the plate, an unclosed mesh, the share of steep overhangs, too small a base area, too high an aspect ratio, features that are too thin, and warping risk on large bottom surfaces. Each finding lists the related parameters. Floating detection splits the mesh into shells, merges shells that touch or intersect into bodies, merges shells fully enclosed by another body into it, then checks whether each body reaches the plate and measures the gap to the nearest body: a narrow gap means the parts were not joined in the model (turning on support would make them print as separate pieces); only a wide gap really needs support. Accepts STL, 3MF and OBJ. This is geometric analysis, not a slicing simulation; thin walls inside the model only show up when actually sliced. No side effects.

Input parameters:

- `buildVolume` (object): Defaults to 256×256×256 mm (Bambu Lab P1S / X1C).
- `lineWidthMm` (number)
- `modelPath` (string, required)
- `overhangThresholdDegrees` (number): Angle from vertical; 0° is a vertical wall, 90° is a horizontal ceiling. Defaults to 45.

Output parameters:

- `buildVolume` (object)
- `findings` (array)
- `fitsBuildVolume` (boolean)
- `floatingBodies` (array): Bodies that do not touch the plate. A gap within 2 mm usually means the parts were not joined during modelling and must be fixed in the modelling software; turning on support would make them print as…
- `inspection` (object)
- `overhangAreaRatio` (number)

### `bambu_measure_clearance` (~253 tokens)

Measure clearance between parts

Measures the smallest clearance between the parts in a 3MF or OBJ, to judge whether a print-in-place mechanism will fuse when printed. Parts that touch each other are first merged into rigid bodies before comparing, because Bambu also stores the colour-change segments of a single solid as separate parts; without merging, one piece would be reported as "clearance 0". When the clearance is too small it suggests compensation, distinguishing outer contours from holes (the enclosed side is a hole to the slicer and is controlled by a different parameter). STL has no part boundaries, so it cannot be measured. No side effects.

Input parameters:

- `minimumClearanceMm` (number): The smallest clearance that prints reliably. Defaults to 0.15 (the practical lower limit for PLA with a 0.4 mm nozzle).
- `modelPath` (string, required): Absolute path to a 3MF or OBJ file; it must be inside an allowed model directory.
- `reportThresholdMm` (number): Part pairs farther apart than this are left out of the report. Defaults to 2 mm.
- `samplingMm` (number): Surface sampling spacing; smaller is more accurate but slower. Defaults to 0.2 mm.

Output parameters:

- `bodies` (array)
- `findings` (array)
- `format` (string)
- `minimumClearanceMm` (number)
- `pairs` (array)
- `partCount` (number)
- `recommendation` (object)
- `tightestGapMm` (number)

### `bambu_compose_model` (~231 tokens)

Compose a 3MF with negative / modifier parts

Builds a Bambu project 3MF from a base body STL plus extra parts. A negative part (negative_part) cuts away where it overlaps, a modifier (modifier_part) applies different settings to its region, and support_blocker / support_enforcer control support. In a Bambu model each of these is just one more part with a label, so no geometry (boolean) engine is needed. The output can be read back item by item with bambu_inspect_project, or passed straight to bambu_slice. Writes a file to the output directory.

Input parameters:

- `baseName` (string): Display name of the base body part. Defaults to body.
- `basePath` (string, required): Path to the base body STL; it must be inside an allowed model directory.
- `name` (string, required): Output file name (.3mf is appended automatically) and object name. Must not contain path separators.
- `parts` (array, required)
- `plateCentre` (object): Where the object lands on the plate. Defaults to the centre of a 256×256 plate (128, 128).

Output parameters:

- `byteLength` (number)
- `nextStep` (string)
- `outputPath` (string)
- `parts` (array)
- `warnings` (array)

### `bambu_inspect_project` (~110 tokens)

Read back the part structure of a 3MF

Reads the objects and parts from a Bambu project 3MF, including each part's subtype and per-part settings. Use it to verify that what was written is really in the file; this is the key advantage of working with files over the GUI: you can compare item by item instead of only looking at the screen. It also flags subtypes that BambuStudio does not recognise. No side effects.

Input parameters:

- `projectPath` (string, required): Path to a Bambu project 3MF.

Output parameters:

- `objects` (array)

### `bambu_search_models` (~140 tokens)

Search for 3D models

Searches for models across platforms. Thingiverse uses its official API (requires THINGIVERSE_TOKEN). MakerWorld and Printables have no official public API, so for them only a search link is returned for a person to open; this is a deliberate downgrade: no scraping or private endpoints pretending to be an API. Do not claim to have searched or downloaded models from those platforms. Does not download any model. Accesses the internet.

Input parameters:

- `limit` (integer)
- `query` (string, required)
- `sources` (array): Restrict to these platforms; omit to query all. See catalogs in bambu_get_status for the available values.

Output parameters:

- `query` (string)
- `results` (array)

## Diagnostics

Captured diagnostic sections: Provenance, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/gjlmotea-slicewise-for-bambu-studio-mcp/gjlmotea-slicewise-mcp#diagnostics

## Score history

- 2026-11-21: 71
- 2026-11-20: 71
- 2026-11-19: 71
- 2026-11-18: 71
- 2026-11-17: 71
- 2026-11-16: 71
- 2026-11-15: 71
- 2026-11-14: 71
- 2026-11-13: 71
- 2026-11-12: 71
- 2026-11-11: 71
- 2026-11-10: 71
- 2026-11-09: 71
- 2026-11-08: 71

## Common questions

### What is the Slicewise MCP server?

Slicewise is an MCP server listed in the public MCP registry as io.github.gjlmotea/slicewise-for-bambu-studio-mcp. Pre-print checks for Bambu Studio: GUI-faithful CLI slicing, override audit, printability. This page covers its npm package (@gjlmotea/slicewise-mcp).

### Is the Slicewise MCP server safe to use?

Slicewise scores 71 out of 100 on VerifyMCP. We recorded 1 known advisory against it as of 21 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. 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 Slicewise MCP server expose?

Slicewise exposes 16 tools: bambu_get_status, bambu_list_presets, bambu_resolve_preset, bambu_compare_presets, bambu_describe_parameters, and 11 more. Their descriptions and schemas cost roughly 2,968 tokens of context every time the server is loaded.

### Is the Slicewise MCP server still maintained?

Slicewise is still listed as active in the MCP registry. We last reached this channel on 21 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 Slicewise MCP server under?

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

### What did VerifyMCP test on the Slicewise MCP server?

VerifyMCP ran 15 checks on Slicewise, covering Malware scan, Known CVEs, Install scripts, Dependency health and 11 more. One item could not be completed, a gap on our side rather than a finding about Slicewise: Stability. One category scores 0 for that reason, because we only credit what we can confirm. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/@gjlmotea/slicewise-mcp
- Socket report: https://socket.dev/npm/package/@gjlmotea/slicewise-mcp
- Repository: https://github.com/gjlmotea/slicewise-mcp
- Changelog RSS feed: https://verifymcp.io/servers/gjlmotea-slicewise-for-bambu-studio-mcp/gjlmotea-slicewise-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/gjlmotea-slicewise-for-bambu-studio-mcp/gjlmotea-slicewise-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/gjlmotea-slicewise-for-bambu-studio-mcp/gjlmotea-slicewise-mcp.json
- HTML version of this page: https://verifymcp.io/servers/gjlmotea-slicewise-for-bambu-studio-mcp/gjlmotea-slicewise-mcp
