# orcaslicer-mcp [Health: Active]

**Category:** 🏭 Industrial & IoT  
**Repository:** https://github.com/MaxEllis/orcaslicer-mcp  
**GitHub Stars:** 104  
**Views:** 10  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/orcaslicer-mcp

## Description
Drive a running OrcaSlicer with AI: load models, tune settings, slice, and analyze results

## Tools
Capabilities this server exposes over MCP:

- **get_status** — Start here: a snapshot of the OrcaSlicer session (build or plugin, project, active presets and their unsaved edits, whether the last slice still holds); for slice numbers use get_slice_status.

    Also lists which keys of each active preset are modified (dirty) and whether a slice is
    running. Read-only.

    Call it first to orient before slicing or editing, to see which settings drift from their
    preset, or to check slice_result_valid before trusting earlier stats. On fork
    v2.4.2-mcp.15 and later `project` is {name, path, dirty}: path is empty until the project
    has been saved, and dirty says File > Save has something to write, so an agent knows when
    to save_project and when the user has been editing in the window. Older builds report
    `project` as the bare path string.

    `connected_to` says in words which one answered: the OrcaSlicer MCP build, or
    `backend: "plugin"`, the OrcaSlicer MCP plugin on stock
    OrcaSlicer: `note` says what it can do. Tell the user before attempting anything it
    cannot (loading models, slicing, renders, plates, projects, saving presets). When that
    plugin is older than the newest release, `plugin_update` says where to get the new one;
    pass its note on to the user.
- **get_config** — Read the current value of settings (all, or only `keys`); with `keys`, `about` also says what each one means, its unit, range and choices.

    Values come back as text, merged across the active print, filament and printer presets. Name the keys you
    need: the whole config is several hundred settings. describe_setting gives the full record of one key.
    
- **set_config** — Change settings on the open project as unsaved edits, all or nothing; a key set to null goes back to its saved preset value; use apply_and_slice to also slice, or edit_preset to change a saved preset.

    Returns {applied, errors}; if any key is invalid the whole batch is rejected and nothing
    changes. Keys set to null are listed under `reverted` (or `already_saved` when they had no
    unsaved edit).

    Overrides show as modified in get_status, are not written to any preset file, and revert
    if the preset is reselected; call save_preset to persist them. Each apply invalidates the
    last slice, so re-slice afterwards. It does not run the physics gate, so for temperature,
    speed, acceleration, or flow keys run check_profile_physics before trusting the result. To
    edit a stored preset rather than the live project, use edit_preset.

    On a multi-filament setup do filament edits before print edits: changing another slot's
    value means select_preset for that slot, which discards unsaved print overrides
    (docs/order-of-operations.md).
- **slice** — Start a slice and return at once without waiting; use slice_and_wait when you want the finished time and filament in the same call.

    The reply is 'started' (a slice began), 'already_valid' (the plate is unchanged and the last
    result still holds), or a conflict if a slice is already running.

    Fire-and-forget: poll get_slice_status for progress and stats, or cancel_slice to stop it.
    Prefer slice_and_wait when you want the finished stats back in one call.
- **get_slice_status** — Read the state, time and filament of the current or last slice, and whether it is out of date; for the warnings alone use get_slice_warnings.

    state is slicing, done, error or idle; stats (print time and filament use) appear when it is
    done, with any warnings or errors. Read-only.

    Poll this after slice to follow progress and read the result; 'idle' means no slice has run
    or it was cancelled. For only the pass/fail warnings use get_slice_warnings; for a
    per-feature time and filament breakdown use get_slice_breakdown.

    When the outcome store holds enough finished prints, `forecast` says how long this slice will
    really take from start to finish on this printer (OrcaSlicer's estimate corrected by how past
    prints compared with theirs, per OrcaSlicer version when possible); relay its summary.
- **get_slice_warnings** — Read only the warnings and errors of the last slice and whether it still holds; the quick check that a fix cleared a warning.

    NOTE: only as complete as the API exposes. On the current fork build this may report
    valid with an empty warnings list even when the GUI shows a plate-boundary toast -
    the fork must populate the plater warning list (tracked as the fork batch). Once it
    does, this reports the real warnings with no change here.
- **get_slice_breakdown** — Read where the time and filament of the last slice go, per feature (walls, infill, support), with a check for speeds capped by the flow limit.

    Returns per-role time/filament + speed/flow ranges, global time-weighted metric
    distributions, per-layer aggregates, and a prediction_check flagging where the profile's
    speed was silently throttled at the flow ceiling ('clamped'). Answers 'which feature is
    the time hog' directly instead of by trial slicing.

    Degrades to {"available": false, "reason": ...} on fork builds that don't emit the
    breakdown, or when there is no valid slice.
- **cancel_slice** — Stop a running slice, or clear a slice stuck in 'slicing'; safe to call when nothing is running.
- **slice_and_wait** — Slice the current plate and wait for the finished time, filament and warnings; the usual way to slice (slice returns at once instead).

    If the plate is already sliced and unchanged, it returns the existing result without
    re-slicing. With enough recorded prints, `forecast` says how long it will really take on this
    printer (see get_slice_status).

    This is the usual way to slice when you want the outcome immediately. For a non-blocking
    start, use slice then poll get_slice_status; to sweep one setting across values, use
    compare_settings.
- **apply_and_slice** — Change settings and slice in one call, returning both; use set_config and then slice_and_wait to keep the steps apart.

    Returns {applied, errors, result}. The changes are atomic (any invalid key rejects the whole
    batch) and unsaved, exactly like set_config, so they revert if the preset is reselected.

    Use this to test the effect of a tweak in a single call. Use set_config then slice_and_wait
    to keep the steps separate, or compare_settings to try several values of one key.
- **compare_settings** — Slice once per value of a single setting and return the raw numbers, putting the value back after; compare_slices adds deltas and a verdict.

    The original value is put back even on error.

    Use it for a quick sweep of a single key. To compare named combinations of settings with
    ready-to-relay deltas and a verdict, use compare_slices instead. Like compare_slices it adds
    one line to OrcaSlicer's MCP panel, not one per trial.
- **compare_slices** — Slice under 2-8 named combinations of settings and compare time, filament and warnings with ready-made deltas and a verdict, putting the settings back after; compare_settings only sweeps one setting.

    Each variant is {"name": str, "changes": {setting: value}}; changes={} means the
    current config as-is (a natural baseline row). Applies each variant over the ORIGINAL
    config (resetting between variants, so they don't stack), slices it, then restores your
    config exactly as it was - nothing is left changed (slice validity is left false, as
    after any un-resliced edit).

    Returns a ready-to-relay `headline` and `table_markdown`, plus structured `variants`.
    All deltas and percentages are ALREADY computed against `baseline` (defaults to the
    changes={} variant, else the first) from the rounded minutes and grams the table shows -
    relay them as given rather than recomputing. `recommended` (starred in the table) is set
    only when one variant is at least as good as every other on time, filament and warnings.
    In a trade-off it is null and the headline reads "No clear winner: X is fastest, Y is
    lightest."; `tradeoff` names them, so leave the choice to the user.

    The trial writes and slices are not recorded in OrcaSlicer's MCP panel; one line such as
    "Compared 3 options · nothing kept" is added instead.

    Each variant is a full slice (minutes); capped at 8. Set detail=True only when a
    per-feature (wall/infill/support) split is wanted - it grows the response ~N x. With
    more than ~5 variants, lead with the recommendation and the extremes, not all rows.
    
- **list_objects** — List the objects in the project with their ids, names, sizes, placement and plate; the object tools take these ids.

    Each has a stable id, name, size_mm, transform (offset/rotation/scale) and, on fork
    v2.4.2-mcp.13 and later, the 0-based plate it sits on (-1 when it is off every plate).
    
- **set_object_config** — Change settings for one object only, all or nothing; use set_config to change them for the whole plate.

    Example: {"wall_loops": 4, "sparse_infill_density": "30%"}.
    
- **duplicate_object** — Add one copy of an object next to it on the plate; call it again for more copies.
- **delete_object** — Remove one object from the plate by id; this cannot be undone through these tools.

    The other objects keep their ids.

    Call list_objects first to get the id. Deleting leaves the last slice invalid, so re-slice
    afterwards. To drop just one copy made with duplicate_object, pass that copy's id.
- **transform_object** — Move, rotate or scale one object by id; use move_object_to_plate to change its plate, or arrange_plate to tidy the whole plate.

    translate=[dx,dy,dz] mm (relative), rotate=[rx,ry,rz] degrees (relative), scale=[sx,sy,sz]
    absolute factor. Provide at least one.

    On fork v2.4.2-mcp.13 and later the object then belongs to whichever plate it sits on,
    as after a drag in the window; list_objects shows the plate. To send an object to
    another plate, move_object_to_plate is simpler than working out coordinates.
- **arrange_plate** — Let OrcaSlicer pack every object on the unlocked plates (Arrange all); use transform_object to move just one.

    It runs as a background job: poll get_job_status until idle.

    With several plates this is OrcaSlicer's "Arrange all": it re-packs the objects of every
    unlocked plate together and deletes plates left empty at the end, which undoes a
    one-part-per-plate layout. To shift one object, use transform_object instead.
- **auto_orient** — Let OrcaSlicer turn every object to its best printing orientation; use transform_object to rotate one by a set angle.

    It runs as a background job: poll get_job_status until idle.
    
- **list_plates** — List the project's plates with their objects and which one is current; the plate tools take the 0-based index shown here.

    For each plate: its 0-based index, name, whether it is current (the one slice, get_gcode,
    render_plate and get_job_status act on), lock state, build volume and the objects it holds.
    Also says how many plates the build allows (max) and whether one can be added or deleted
    right now. Read-only.

    Plate numbers shown in the OrcaSlicer window are 1-based; every tool here takes the
    0-based index from this list. Needs fork v2.4.2-mcp.13 or later.
- **get_printer_slots** — Read the filament trays of an Elegoo Centauri Carbon 2 with a CANVAS unit; only for that printer, and slow (up to about 18 s).

    It reports which tray is active, and for each tray its label (A1, A2, ...), status,
    material, brand and colour. Read-only; needs fork v2.4.2-mcp.14 or later. OrcaSlicer's API
    serves one request at a time while the printer is asked, so other tools wait.

    Per tray: status is loaded, preloaded (filament waiting at the feeder, not yet pulled in),
    disconnected or error. ready is true when the tray can be printed from now.
    unknown_filament is true when the tray reports no filament type or name. Use canvas_id and tray_id from here in
    set_filament_slot_mapping.

    When the printer is not supported or not reachable the reply is supported false with a
    reason (not_elegoo_cc2, no_canvas, unreachable, too_many_clients, registration_refused,
    timeout, printer_error, firmware_too_old) and a message. Relay the message to the user.
- **get_filament_slot_mapping** — Show which CANVAS tray each filament would print from on the next Send (Elegoo Centauri Carbon 2 only); read-only.

    The filaments listed are the ones on the plate the next Send would use. Needs fork
    v2.4.2-mcp.14 or later. It reads the printer when no slot list is cached, so it can take up
    to about 18 seconds, and OrcaSlicer's API serves one request at a time meanwhile, so other
    tools wait.

    The reply names the plate (0-based, the current plate) and supported (true, or false with
    a reason). Each filament has its 0-based index, type, name, colour, the tray it maps to (or null), the
    source of that choice (saved, matched, user, api or none) and any warnings. valid is true
    when that Send would go through; if not, problems says why (an unmapped filament, a tray that
    is not ready). Call it after slicing or changing filaments, before telling the user the
    plate is ready to send. Nothing is sent to the printer. A supported false reply carries a
    reason to relay, as get_printer_slots does.
- **set_filament_slot_mapping** — Choose which CANVAS tray each filament prints from on the next Send (Elegoo Centauri Carbon 2 only); it starts nothing.

    Returns the same reply as get_filament_slot_mapping, so check valid and problems. Needs fork
    v2.4.2-mcp.14 or later. It reads the printer when no slot list is cached, so it can take up
    to about 18 seconds, and OrcaSlicer's API serves one request at a time meanwhile, so other
    tools wait.

    The list REPLACES the whole mapping set through the API: a filament left out gets no tray
    from the API, and an empty list clears the API choices so Send falls back to the saved
    choices and automatic matching. Include every filament you want pinned.

    This starts nothing. OrcaSlicer's own Send dialog opens pre-filled with this mapping and
    the user still clicks Send. Each tray can serve only one filament (422 duplicate_tray), the
    tray must be ready (422 tray_not_ready), and the indexes must exist (422 unknown_filament_index, which
    also covers a project filament that is not on the plate; unknown_tray, slots_unavailable when the printer could not be read; the reply then
    says why). Malformed lists get 400: each filament at most once, and integers for
    filament, canvas_id and tray_id. Use get_printer_slots first to pick trays whose material and colour fit.
- **add_plate** — Add an empty plate, like the toolbar's Add plate button, so parts can print separately.

    Returns the new plate's 0-based index for move_object_to_plate and select_plate.

    Use it when parts should print separately: load them, add a plate, move the second
    part across with move_object_to_plate, then select_plate and slice each one. A plate
    cannot be added while a slice is running (409) or at the build's plate limit (422).
    On OrcaSlicer 2.5, the 2nd, 5th and 10th plates widen the plate grid, which clears
    every plate's slice result, as the toolbar button does: slice again afterwards.
- **select_plate** — Make a plate the current one, so slicing, G-code, renders and slice status act on it.

    get_slice_status then reports that plate's own result: its stats if it is still sliced,
    otherwise idle with "plate N is not sliced". Switching plates leaves unsaved config
    overrides alone; it changes only which plate is sliced. Selecting the plate that is
    already current is a no-op.
- **delete_plate** — Delete a plate; the objects on it are parked beside the bed, not deleted.

    OrcaSlicer parks them as the toolbar's delete does, and the reply says how many were moved
    off-plate (objects_moved_off_plate). Use move_object_to_plate to put them somewhere
    printable. OrcaSlicer parks them where the next plate appears, so an add_plate straight
    after a delete picks them back up.

    The only plate cannot be deleted (422 last_plate). Call list_plates first for the index;
    this cannot be undone through the API.
- **move_object_to_plate** — Move an object onto another plate by its index; simpler than transform_object for changing plates.

    Coming from a plate it keeps its position relative to that plate (front-left of plate 1
    lands front-left of plate 2); coming from off-plate (parked beside the bed) it lands at the
    destination's centre. If it then overlaps a part, shift it with transform_object;
    arrange_plate would re-pack every plate together.

    list_objects reports each object's plate (-1 when off every plate). Moving leaves both
    plates' slices invalid, so re-slice. An object already on that plate is left where it
    is (moved: false); a locked plate at either end refuses the move (plate_locked).
- **get_project** — Read the open project as a file (name, path, unsaved changes); check it before save_project, open_project or new_project.

    Also reports whether it has been saved, plate and object counts, the preset groups with
    unsaved edits (modified) and how many entries File > Recent holds; path is empty until the
    first save. Read-only. Needs fork v2.4.2-mcp.15 or later.
    
- **save_project** — Save the open project as a .3mf with its plates and settings (File > Save or Save As); save_gcode saves the sliced G-code instead.

    It writes exactly what File > Save / Save Project As writes: plates, object placement,
    per-object and per-plate settings, height-range modifiers, slot presets and colours, and
    unsaved config overrides. No dialog opens; OrcaSlicer's own prompts are answered from the
    arguments. To create a new project file, call new_project and then save_project with a path.

    Afterwards get_status reports the new path and dirty false, and the file joins File >
    Recent. Save early: everything set up through these tools lives only in the open session
    until it is saved, and is lost if OrcaSlicer closes. A save is refused while a slice runs
    (slicing). Replacing an existing file also needs Preferences > Remote API > 'Allow
    deleting and replacing project files' in OrcaSlicer (blocked_by_remote_api_policy
    otherwise). Needs fork v2.4.2-mcp.15 or later.
- **open_project** — Open a saved .3mf project with its plates and settings, replacing the open one; load_model only adds a model's geometry.

    As with File > Open Project, plates, objects, per-object and per-plate settings, slot
    presets and colours all come back. Use open_recent_project for an entry of File > Recent and
    browse_projects to find project files in a folder.

    The two prompts OrcaSlicer would show are answered from the arguments, so nothing blocks.
    Unsaved preset overrides are dropped before the open because the project's config
    replaces them; the reply names those groups in discarded_changes. Call get_project first
    if you are unsure whether the user has unsaved work in the window, and pass
    if_unsaved='save' or 'discard' deliberately. A project that brings its own scripts, custom
    G-code or printer connection is refused (blocked_by_remote_api_policy, with the keys)
    unless the user allows those edits in OrcaSlicer's Preferences; nothing changes then.
    Needs fork v2.4.2-mcp.15 or later.
- **open_recent_project** — Open an entry of File > Recent by its position in list_recent_projects; open_project takes a path instead.

    Same behaviour and arguments as open_project. The list can change between calls (a save or
    an open moves its file to the top), so list first and open straight after; a file no longer
    on disk answers file_not_found and forget_recent_project removes the entry. Needs fork
    v2.4.2-mcp.15 or later.
    
- **new_project** — Start a new, empty project (File > New Project) without a dialog.

    The unsaved-changes prompt is answered by if_unsaved. OrcaSlicer's second prompt, keep or
    discard modified presets, is answered with Keep: unsaved preset overrides carry over into
    the new project and the reply names them in kept_changes (select_preset drops them if that
    is not wanted). Follow with load_model and save_project to create a project file. Needs fork
    v2.4.2-mcp.15 or later.
    
- **list_recent_projects** — List File > Recent, most recent first, with the index that open_recent_project takes.

    For each entry: its path, project name, whether the file still exists, whether it is the
    open project, and its size and last-modified time. Read-only. Needs fork v2.4.2-mcp.15 or
    later.
    
- **forget_recent_project** — Remove an entry from File > Recent, or clear the list; the file on disk stays.

    By path or index. Useful after a file was deleted or moved outside OrcaSlicer. The reply
    names what was forgotten and returns the list as it is now. Needs fork v2.4.2-mcp.15 or
    later.
    
- **browse_projects** — List the .3mf project files in one folder on the OrcaSlicer machine; list_recent_projects shows File > Recent instead.

    Not recursive, newest first: path, project name, size and last-modified time, and whether
    each is the open project. Read-only. Use it to find a project to open_project, or to pick a
    free name before save_project. Needs fork v2.4.2-mcp.15 or later.
    
- **move_project_file** — Move or rename a .3mf project file on disk; the window follows when it is the open project.

    When it is the open project's file, the title, project name and File > Recent show the new
    path, and the next save_project writes there. Any other recent-list entry naming the old
    path is pointed at the new one. The file's content and the project's dirty state do not
    change. Fails with exists when something is already at `to` and overwrite is off; replacing
    it also needs Preferences > Remote API > 'Allow deleting and replacing project files' in
    OrcaSlicer. Needs fork v2.4.2-mcp.15 or later.
    
- **delete_project_file** — Delete a .3mf project file from disk for good; forget_recent_project only takes it off File > Recent.

    There is no trash, and the file leaves File > Recent too. Only .3mf files can be deleted
    this way, and never the open project's own file: new_project or open_project first. Confirm
    with the user before calling this on a file they did not just ask to remove. OrcaSlicer
    refuses it (blocked_by_remote_api_policy) unless the user ticked Preferences > Remote API >
    'Allow deleting and replacing project files'. Needs fork v2.4.2-mcp.15 or later.
    
- **get_job_status** — Check whether arranging or orienting is still running; wait for idle before reading positions or slicing.

    Read-only.

    arrange_plate and auto_orient start async jobs; poll this until it reports idle before you
    read object positions or slice, so you act on the settled layout rather than a mid-move
    state.
- **watch_events** — Listen to OrcaSlicer's live events (slices, setting changes, projects opened) for a few seconds.

    Events: slice.*, config.changed and project.opened, over a bounded window.
    
- **find_config_keys** — Find setting keys that contain a piece of text, from the live settings; search_settings also matches labels and descriptions, offline.

    Helps discover among the ~600 keys.
    
- **diagnose_plate** — Start here when a plate won't slice or fit: status, objects, bed and skirt or brim settings and slice warnings in one call.

    One call instead of chaining status, objects and config.

    Slice warnings are only as complete as the fork exposes today (see get_slice_warnings).
    For a 'does it fit the bed' estimate, pair with check_placement.
- **check_placement** — Estimate before slicing whether every object, with its skirt or brim, fits the bed; get_slice_warnings has the exact verdict after.

    Returns per-object fit, expanded first-layer bbox, per-edge clearance (mm), and overflow.

    APPROXIMATE: uses the object footprint from size+offset, not the sliced toolpath (skirt
    arcs, half-line-width, travel/wipe excluded); single-instance objects only. At ~mm
    margins the true verdict needs get_slice_warnings - this is a fast first-pass.
- **consult** — Look up curated slicing advice and saved notes for a goal or symptom; call it before choosing settings.

    ALWAYS call before deriving or changing settings for a user goal. Composes principles per
    situation, never returns preset bundles. Falls back to find_config_keys/web search if empty.

    When recommending, present 2-3 concrete options quantified with
    predicted print time and filament mass from real slice results (slice +
    status tools) - never adjectives alone.
- **check_profile_physics** — Check the live settings, plus optional proposed changes, against flow, temperature, geometry and cooling limits; run it before save_preset.

    Deterministic: it fetches the live config, overlays the optional `changes` and runs the
    math. RUN THIS BEFORE save_preset. verdict=blocked means DO NOT SAVE.
    
- **remember** — Save a short note for future sessions (about a printer, the user or a project); consult finds it again.

    scope: 'machine:<printer>/<filament>', 'user', or 'project:<name>'. Local plain files;
    user-readable and deletable.
    
- **describe_setting** — Explain one setting from its key: label, meaning, type, unit, allowed range and choices; works offline.

    Authoritative, from OrcaSlicer's own source: label, tooltip, type, unit, valid range, enum
    values and default. Read-only, so it works even when OrcaSlicer is not running.

    Use it to learn a setting's exact type and allowed values before writing it with set_config
    or edit_preset. To find candidate keys by keyword first, use search_settings.
- **search_settings** — Find settings by words in their key, label or description, offline; describe_setting then explains one.

    Returns compact matches (key, label, category, short tooltip), ranked key and label matches
    first.
    
- **load_model** — Load a model file (.stl, .obj, .3mf geometry, .step) from the OrcaSlicer machine onto the plate; open_project opens a saved project instead.

    The path is on the OrcaSlicer host. .step/.stp need fork v2.3.2-mcp.3 or later; large STEP
    files can take a minute to tessellate, and the call waits. A .3mf is imported as geometry
    only.
    
- **select_preset** — Switch the active print, filament or printer preset; without a filament slot this drops every unsaved edit.

    With `slot` (filament only), only that slot's filament preset changes, like picking it
    in the sidebar's combo for that slot, and no unsaved edits are discarded. On a
    single-filament printer slot 1 is the Filament tab's preset, so it behaves like the call
    without `slot` below. Needs a slicer build that lists 'preset_slot' in get_status
    capabilities; older builds would ignore the slot and switch the Filament tab instead, so
    this tool refuses there.

    Without `slot`: discards unsaved overrides in EVERY preset group, not just the one being switched: a
    filament switch also drops unsaved print and printer edits, including ones made by hand
    in the OrcaSlicer window. That is deliberate (OrcaSlicer consults the other groups when
    switching, and any unsaved one would open a modal dialog nothing can dismiss remotely),
    so call save_preset first if any unsaved edit should survive. Newer slicer builds report
    which groups were affected as 'discarded_changes' in the reply.

    This also makes it the canonical way to reset dirty config. It leaves the last slice
    invalid, so re-slice afterwards. Use list_presets for valid names. Because of this, make
    filament selections and edits before print-group edits (docs/order-of-operations.md).
- **save_preset** — Save the current settings as a named user preset; edit_preset changes a stored preset in one step instead.

    It creates or updates the preset, visible in the GUI immediately. type =
    print|filament|printer. detach=True saves it standalone instead of inheriting the current
    base preset; use it when creating a filament preset for a DIFFERENT material than the one
    selected, otherwise the new preset inherits the base's filament_type and temperatures.

    Run check_profile_physics first; do not save when verdict=blocked.
- **list_presets** — List the print, filament and printer presets: the user's own and the selected ones, or all with include_system.

    Each with system/selected/visible flags.

    F12: by default returns only USER presets plus whatever is currently SELECTED -
    the built-in system presets are ~400 entries of noise. Pass include_system=True
    for the full list, and/or type='print'|'filament'|'printer' to restrict to one
    category. `hidden_system` reports how many system presets were filtered out.
- **set_layer_height** — Turn adaptive layer height on or off for one object; set_height_range sets a fixed height over a Z band instead.

    mode='adaptive' (quality 0..1, higher = finer detail) generates an adaptive profile;
    mode='reset' (aliases: 'default', 'none') restores uniform layers.
    
- **set_height_range** — Set a layer height over a Z band of one object; set_layer_height makes the whole object adaptive instead.

    For example 0 to 5 mm printed at 0.1 mm for finer detail near the base. Passing the same
    min_z and max_z again updates that band's height; clear=True removes every band on the
    object.

    Bands are per-object and invalidate the last slice, so re-slice afterwards. For a single
    height across the whole object use set_layer_height instead. Get the id from list_objects.
- **get_preset_config** — Read every setting of a named preset without selecting it; get_config reads the live settings.

    type = print|filament|printer.
    
- **delete_preset** — Delete one of the user's presets (never a system preset or the selected one).

    type = print|filament|printer.
    
- **edit_preset** — Change a stored preset and save it under the same name, after the physics check; set_config changes only the open project.

    It selects the preset, applies the changes atomically and saves under the same name. Runs
    the check_profile_physics gate first (F15) and refuses with error=physics_blocked if the
    changes would INTRODUCE a failing physics check (pre-existing failures do not block
    unrelated edits). For type='filament', checks that also depend on the currently selected
    PRINT preset (flow_ceiling, temp_vs_flow) do not block; they come back as
    cross_layer_warnings, because a filament preset pairs with many print presets.
    
- **rename_preset** — Rename one of the user's presets; the renamed preset becomes the selected one.

    It copies the preset to new_name, selects the copy and deletes the original. System presets
    are read-only.

    Because it selects the renamed preset, this leaves it active and discards unsaved config
    overrides, the same as select_preset, and leaves the last slice invalid, so re-slice
    afterwards.
- **get_gcode** — Return the last slice's G-code as text; save_gcode writes it to a file and records the slice.
- **describe_plate** — Describe from the G-code how each sliced part stands, touches the bed, overhangs, is supported and where its seams are; needs a finished slice.

    Machine-readable facts per object, so you can answer orientation and placement questions
    instead of guessing from Euler angles or a picture: how the part stands (flat / tilted / on
    an edge or corner, from first-layer contact versus its widest layer), the first-layer
    footprint as islands, where overhang extrusions concentrate by 10 mm height band, where
    support stands and where its interface touches the part, and which side the outer-wall seams
    sit on (checked against seam_position). Each object gets a server-written summary sentence;
    relay it rather than recomputing. Read-only. Needs a valid slice; returns {"error":
    "not_sliced"} otherwise. Copies of one object are aggregated (Orca labels every copy 0);
    footprint islands still show per-copy contact. The parsed result is cached per slice (the
    G-code itself is still downloaded each call to detect a new slice). All bboxes are [x0, y0,
    x1, y1] in plate millimetres.

    `settings_check` says whether the G-code was sliced with the settings that are set now
    (layer height, walls, infill, temperatures, speeds, supports, bed type, print sequence, spiral
    vase and every setting with an unsaved edit); any `differ` entry names what the slice used
    instead. Tell the user before printing when it lists differences.
    
- **save_gcode** — Save the last slice's G-code to a file and record the slice so the print can be learned from later; hand the path to the printer tools.

    The record (model, a fingerprint of the objects' names and sizes, full settings snapshot,
    and OrcaSlicer's time and filament estimates) goes in the local outcome store under that
    filename. When that file is printed, list_print_history (or klipper-mcp's recorder) matches
    the finished job by filename, so the real result joins back to these settings. Returns the
    saved path; hand it to klipper-mcp's start_print. Default filename:
    <object>_<timestamp>.gcode. Never overwrites an existing file: a name collision gets a -2,
    -3, ... suffix. Writes into a gcode folder under PRINT_OUTCOMES_DIR if set, else under
    ~/.orcaslicer-mcp; the folder is created if missing. If the store write fails, the
    file is still saved and outcome_recorded is False.
    
- **recall_prints** — Recall how past prints of this model turned out and with which settings; call it before slicing.

    Matches the current plate by geometry (or by model_name if given / the slicer is offline),
    returning each past print's result (success/cancelled/error), your recorded verdict (e.g.
    'warped'), and the settings it was sliced with. Call this BEFORE slicing and tell the user
    anything relevant (a past warp, a failed layer height). Each row also carries failure_reason
    (the printer's own words, when known) and the slicer's estimates (est_time_s,
    est_filament_g). duration_s is Moonraker's whole job time, including heating up and any
    pauses, so beside the estimates it overstates an overrun; list_print_history compares the
    print time (without heating or pauses) with the estimate. filament_g comes from the G-code
    file's own estimate, because printers don't report grams. Call list_print_history first to
    pull in recent results. Read-only. Returns available=false and nothing else when no outcome
    store exists yet. If neither geometry nor name matches, it returns the most recent prints of
    ANY model with matched_by='recent'; never attribute those to the current model.
    
- **render_plate** — Render a picture of the plate: the models before slicing (editor) or the toolpaths after it (preview).

    view="editor": the models on the bed BEFORE slicing - use to check
    orientation, plate contact, and first-layer footprint (an Euler triple is
    near-unreadable; this is the ground truth). view="preview": the sliced
    toolpaths colored by feature role AFTER a successful slice - support is
    visibly distinct, so use it to check where support actually went.
    angle: iso|top|front|left|right|rear|bottom.
    frame: "plate" zooms out to the whole bed (where the part sits, footprint),
    "object" zooms in on the model/toolpaths (detail). Defaults to "plate" for
    the editor view and "object" for the preview view; pass it explicitly when
    a side view of a small part would otherwise be a speck on a big bed.
    
- **get_printer_status** — Read what the 3D printer is doing now (state, temperatures, job progress, problems); wait_for_printer waits for a point in a print.

    It reports state (idle, heating, printing, paused, finished, cancelled, error, shutdown,
    offline), nozzle and bed temperatures with their targets, the current job (file, progress,
    layer, time elapsed and left, and what the time left is based on), and any problems the
    printer reports, each in the printer's own words with a plain-English hint for common ones.
    Relay `headline` as-is. Never invent a cause the printer did not report.

    Finds the printer from OrcaSlicer's active printer profile (or ORCA_PRINTER_URL), so it needs no
    extra setup once the printer is connected in OrcaSlicer. Klipper (Moonraker) printers report the
    most; OctoPrint reports basic status. Read-only: it never sends commands to the printer.
- **wait_for_printer** — Wait until the printer is heated, printing, past the first layer or finished, checking every 5 seconds.

    Returns as soon as it happens (met: true), or at the timeout with the latest status (met:
    false). It also returns early, with stopped_early saying why, when the printer reports a
    fault, when the job ends before the point it waits for (a cancelled print, say), or after
    losing contact ("Lost contact with the printer"). A job that completes successfully while
    the wait is for 'printing' or 'first_layer_done' counts as met (a one-layer print passes
    both at once). A met result can carry stopped_early too, for example a job that finished
    with an error. Waiting for 'finished' when nothing is printing returns at once with the note
    'nothing is printing'. Read-only: it never sends commands.
    
- **list_print_history** — List how recent prints on the printer ended against the slicer's estimates (Klipper only); recall_prints looks up one model's past prints.

    For each finished job: result (success, cancelled or error), how long it took against the
    slicer's estimate, filament used, and for failed or stopped jobs the printer's own reason
    while its console still holds it. `summary` says how the slicer's time estimates compare
    with reality once there are a few finished prints. Also copies those jobs into the local
    outcome store (safe to repeat), so recall_prints can learn from them. Klipper printers only.
    `limit` is capped at 50.
    
- **check_printer_match** — Check the active OrcaSlicer profile against the printer's own Klipper settings (nozzle, bed, speeds, temperatures); warnings only.

    Compares nozzle size, bed size and height, the highest speeds and accelerations, nozzle and
    bed temperatures, and firmware retraction against the printer's own Klipper settings. Each
    check comes back ok, warn or unknown with both values and why it matters; relay `headline`
    and the warnings. It never changes or blocks anything itself. When speeds or accelerations go
    past the printer's limits, `fix` holds the set_config changes that lower just those settings to
    the limits: offer them to the user and pass `fix` to set_config if they agree. Run it before
    printing with a new or edited profile, or when prints take longer than estimated. Klipper
    printers only; needs OrcaSlicer running.
    

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "orcaslicer-mcp": {
    "command": "uvx",
    "args": ["orcaslicer-mcp"]
  }
}
```

## Documentation

## What orcaslicer-mcp does

orcaslicer-mcp gives an MCP client control and read access to a live OrcaSlicer project. It can load STL, OBJ, and 3MF models, with STEP and STP support on the specified fork builds, then list, duplicate, delete, transform, arrange, or auto-orient objects on the active plate. It also exposes project configuration, preset-related operations, slicing controls, placement checks, and background-job status.

The slicing workflow covers both asynchronous and blocking use. An agent can start a slice and poll for progress, or wait for final statistics and warnings in one call. Results include print time and filament usage. Where the fork emits the required data, `get_slice_breakdown` adds per-feature time, filament, speed, and flow information, along with a prediction check for speeds limited by the flow ceiling.

## How it works

The MCP server communicates with OrcaSlicer at a configured address, using localhost by default. The model is supplied by the MCP client; the package does not include one. Project changes are reflected in the running GUI. Configuration writes through `set_config` and `apply_and_slice` are atomic, but they create unsaved overrides rather than changing preset files. Selecting another preset discards those overrides, while `save_preset` can persist suitable changes after validation.

For controlled experiments, `compare_settings` tests multiple values for one key and restores the original value. `compare_slices` applies named variants independently over the original configuration, slices each one, and restores the prior configuration afterward. Its response includes structured results and precomputed comparisons against a baseline.

Offline setting tools help identify valid keys and values before editing. `search_settings` and `find_config_keys` locate candidates, while `describe_setting` returns a setting's type, unit, range, enum values, default, label, and tooltip. `consult` retrieves curated slicing guidance and saved context notes. `check_profile_physics` overlays proposed changes and evaluates flow, temperature, geometry, and cooling constraints before a preset is saved.

## Tools and capabilities

- Inspect session, project, preset, slice, object, and background-job state.
- Load supported model files and manipulate objects by stable ID.
- Read or change merged OrcaSlicer configuration values.
- Slice synchronously or asynchronously, cancel stale jobs, and retrieve warnings.
- Compare settings or complete slice variants without leaving test changes applied.
- Diagnose plate fit using object footprints, skirt or brim expansion, and edge clearances.
- Query per-feature timing, filament use, flow ranges, and layer aggregates when available.
- Store machine, user, or project context notes in local plain files.

## Limitations and notes

Configuration edits invalidate the previous slice, so a changed project should be sliced again before relying on earlier statistics. `set_config` does not perform the physics check automatically; temperature, speed, acceleration, and flow changes should be checked before trusting or saving a profile. Deleting an object is permanent within the session and cannot be undone through the API.

Placement checks are estimates based on object footprints and offsets rather than final sliced toolpaths. They exclude details such as skirt arcs, half-line-width effects, and travel or wipe moves, so near-boundary cases should also be checked through slice warnings. Warning completeness depends on what the connected OrcaSlicer fork exposes, and breakdown data can be unavailable when the fork does not emit it or when no valid slice exists.

Arrange and auto-orient run asynchronously; poll `get_job_status` until the worker is idle before reading positions or slicing. The server does not bundle an AI model. When printer tools are used, they make read-only requests and send no commands or uploads to the printer.

_Full upstream README: https://allmcps.com/mcp/orcaslicer-mcp/readme_