sketchup-mcp2
The server lets an MCP-aware AI client inspect and modify a live SketchUp model through typed tools plus an arbitrary-Ruby escape hatch.
Create and delete SketchUp primitives (cube, cylinder, cone, sphere) as groups, with millimeter dimensions and absolute bbox-min positioning.
Move, rotate, and scale groups/components relative to their bounding box.
Assign materials/colors by name or hex to groups, components, faces, or edges.
Perform boolean union, difference, and intersection operations on solids.
Chamfer and fillet feature edges with configurable distance/radius and segments.
Create mortise-and-tenon, dovetail, and finger joints between boards.
Export the scene to SKP, OBJ, DAE, STL, PNG, or JPG on the SketchUp host.
Inspect the model: file info, units, bounding boxes, entity counts, layers, components, selection, and component search.
Create layers/tags and list existing layers.
Capture viewport screenshots with optional view presets, zoom extents, styles, and view restoration.
Undo the last atomic MCP tool operation.
Run arbitrary Ruby inside SketchUp via
eval_ruby, subject to the extension's settings gate.Probe Python↔Ruby version compatibility and support multiple concurrent MCP clients.
Provides tools for creating, modifying, and manipulating 3D models in SketchUp, including component management, boolean operations, joinery, and scene export.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@sketchup-mcp2 Create a 3D cube and color it blue"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP Server for SketchUp
Connect Claude (or any MCP-aware AI client) to SketchUp for prompt-driven 3D modeling.
Two-process bridge:
Python MCP server (
sketchup-mcp2on PyPI) — exposes typed tools to the LLM via the Model Context Protocol.Ruby SketchUp extension — runs a TCP server inside SketchUp and executes commands against the live model.
Quickstart
1. Install the SketchUp extension
Either grab the latest .rbz from the Releases page or build it from source:
gem install --user-install rubyzip
(cd mcp_for_sketchup && ruby package.rb)
# → mcp_for_sketchup/mcp_for_sketchup_v<version>.rbzIn SketchUp: Window → Extension Manager → Install Extension, pick the .rbz, restart SketchUp. The plugin ships with eval_ruby — arbitrary Ruby execution inside SketchUp — enabled by default; uncheck Enable Ruby evaluation in Plugins → MCP Server → Settings... to close the gate.
2. Start the server inside SketchUp
Plugins → MCP Server → Start Server — by default listens on 127.0.0.1:9876.
3. Configure your MCP client
For Claude Code / Claude Desktop, add to .mcp.json (or claude_desktop_config.json):
{
"mcpServers": {
"sketchup": {
"command": "uvx",
"args": ["sketchup-mcp2"],
"env": {
"SKETCHUP_MCP_HOST": "127.0.0.1",
"SKETCHUP_MCP_PORT": "9876",
"SKETCHUP_MCP_TIMEOUT": "60",
"SKETCHUP_MCP_LOG_LEVEL": "INFO"
}
}
}
}uvx will pull sketchup-mcp2 from PyPI automatically — install uv if you don't have it.
That's it. Ask Claude things like "create a 1.2 × 0.8 m oak dining table" and watch it happen.
Related MCP server: SketchupMCP
Features
Tool catalogue
Category | Tools |
Geometry |
|
Materials |
|
Booleans |
|
Edge ops |
|
Joinery |
|
Export |
|
Introspection |
|
View |
|
Lifecycle |
|
Escape hatch |
|
All dimensions in millimeters; angles in degrees. Every entity-returning handler also responds with bbox_mm so the LLM can re-locate entities by bounding box if their IDs go stale after destructive ops.
Capabilities
Multi-client support — N concurrent MCP clients can be connected at once (e.g. Claude Desktop + a smoke-test script + your own Python notebook). Operations are still serialised on the SketchUp UI thread; frames are dispatched in a single global FIFO ordered by decode arrival.
One-time version handshake — every TCP connection begins with a JSON-RPC
hellocarryingclient_version; the server validates against its supported range and replies withserver_version+client_id. Incompatible pairs surface immediately asIncompatibleVersionErrorand the socket is closed.Atomic undo — every mutating handler wraps the edit in
model.start_operation/commit_operation, so a singleEdit → Undorolls back the whole call.MCP prompt
sketchup_modeling_strategy— surfaced in MCP-aware clients' slash menu; teaches the model project conventions (mm units, typed-tools-vs-eval_ruby, pitfalls like reversedGroup#subtract).Settings dialog —
Plugins → MCP Server → Settings...for host / port / log level. Log level applies immediately; host/port changes prompt for a restart.
Configuration
Python side (env vars in .mcp.json)
Variable | Default | Description |
|
| Where to connect to the SketchUp extension |
|
| TCP port |
|
| Per-tool-call timeout (seconds); keep it well above 30 s (the default 60 is fine) — a chamfer/fillet call starts no new cut after 30 s inside SketchUp and then rolls back, and a client that gives up first can miss an edit that still commits |
|
|
|
Ruby side (Settings dialog inside SketchUp)
Open Plugins → MCP Server → Settings... to change Host, Port, Log Level, the Ruby evaluation gate, and log-to-file options. Values persist in SketchUp's preferences under section MCPforSketchUp. No environment variables are read on the Ruby side.
The Ruby side logs at WARN by default, so it stays quiet in SketchUp's shared Ruby console; any line it does print is prefixed [MCPforSU] with a UTC timestamp. Enable Log to file to mirror every line to a UTF-8 log file in addition to the console (Plugins → MCP Server → Show Log opens it). The file is written append-only — there is no automatic rotation or size cap, so rotate or clean it up yourself for long-lived sessions.
eval_ruby — the arbitrary-Ruby escape hatch — is enabled by default. Uncheck Enable Ruby evaluation in the Settings dialog to close the gate; the setting persists across SketchUp restarts, and re-enabling it pops a blocking confirmation spelling out the risk (arbitrary Ruby ⇒ full filesystem / network / shell access). With the gate closed, a client's eval_ruby call comes back as a plain message telling the user how to re-open it.
Per-call review. Open gate or not, the exact Ruby a client sends stays visible in your MCP client — Claude Desktop and Claude Code display every tool call's arguments and let you approve or deny each one before it runs, so you can review each snippet case by case. (That per-call prompt is skipped only if you opt out of approvals, e.g. Claude Code's --dangerously-skip-permissions.) This review covers only calls made through that client — see Security model.
⚠ Security warning: binding the host to
0.0.0.0exposes the MCP server — includingeval_ruby, which runs arbitrary Ruby inside SketchUp — to the entire local network with no authentication. Use only on trusted networks (host → VM, isolated lab). See Security model; for multi-machine setups use the SSH tunnel described there.
Security model
The plugin's TCP socket has no authentication. Anything that can open a connection to its port can call every tool, and eval_ruby — arbitrary Ruby with full filesystem, network and shell access — is one of them for as long as Enable Ruby evaluation is on, which it is by default. That means any process on the SketchUp machine, and other machines too when Host is not a loopback address.
Approval in your MCP client covers only calls made through that client. Claude Desktop and Claude Code show each call's arguments before it runs; a process that talks to the socket directly bypasses that review.
The defaults are safe on a single-user machine. The plugin listens on
127.0.0.1, so only local processes can connect, and they already run with your permissions.An upgrade can open the eval gate without a dialog. It affects an install that never saved the Settings and upgrades from a
-warehousebuild (the eval-disabled variant published with 0.2.0 and 0.3.0), whereeval_rubyshipped closed: with no stored preference the shipped default applies (eval_rubyis on since 0.3.1) and no confirmation appears. Open Settings once and uncheck Enable Ruby evaluation if you do not want it. An install where it was unchecked explicitly stays that way.Split host (MCP client on a Linux VM, SketchUp on Windows): tunnel instead of binding to the LAN. Keep the plugin on
127.0.0.1and run this on the Windows machine:ssh -N -R 9876:127.0.0.1:9876 user@linux-vmThe MCP server on the Linux side then connects to
127.0.0.1:9876, the default. You need the OpenSSH client on Windows (built into Windows 10/11) andsshdon the VM. The tunnel's VM end listens on the VM's loopback, so every process on the VM, under any user, reaches the plugin —eval_rubyincluded, while the gate is open — through it; sshd's defaultGatewayPorts nois what keeps the port off the VM's network.Binding Host to a LAN address or
0.0.0.0exposes the plugin to every machine that can reach the port —eval_rubyincluded, while Enable Ruby evaluation is on. The Settings dialog's inline warning appears only for wildcard hosts such as0.0.0.0, not for an explicit LAN IP; the server itself logs a WARN when it binds to any non-loopback host (in SketchUp's Ruby Console, and in the log file if you enabled it).
Examples
Things you can ask Claude:
"Create a simple dining table — 1.2 × 0.8 m, 760 mm tall, oak finish"
"Highlight every component smaller than 100 mm in any dimension"
"Make the selected component red, then move it 100 mm up"
"Export the scene as STL for 3D printing"
"Build a small arts-and-crafts cabinet using
eval_rubywith dovetails"
For richer Ruby recipes that drive the SketchUp API directly — framed walls, gable/hip roofs, joist arrays, follow_me extrusions, world-space transforms, common pitfalls — see docs/sketchup-ruby-cookbook.md.
Working examples and load tests live in examples/:
smoke_check.py— 26-step end-to-end verification of every tool category.smoke_multi_client.py— concurrent multi-client load test.
Architecture
Claude (MCP client)
↕ MCP (stdio)
Python MCP server (FastMCP) src/sketchup_mcp/
↕ TCP — JSON-RPC 2.0, 4-byte big-endian length-prefix framing, 64 MiB cap
Ruby SketchUp extension (server) mcp_for_sketchup/mcp_for_sketchup/
↕ SketchUp Ruby API
Live SketchUp modelThe Ruby side runs entirely on the SketchUp UI thread via UI.start_timer callbacks (SketchUp's Ruby is single-threaded — no native threads allowed). The Python side holds one persistent TCP socket per process and serialises tool-calls with an asyncio.Lock.
Source layout:
Python:
src/sketchup_mcp/{tools,connection,config,compat,errors,prompts}.pyRuby:
mcp_for_sketchup/mcp_for_sketchup/{core,handlers,helpers,ui}/
See CLAUDE.md for the project's working notes and non-obvious constraints (unit conversions, reversed boolean semantics, framing details, etc.).
Development
Python package (editable install)
uv pip install -e .
python -m sketchup_mcp # direct
uvx sketchup-mcp2 # production-style (from PyPI)Tests
ruby test/run_all.rb # Ruby unit tests (minitest; stdlib + rubyzip for the package test)
uv run pytest tests/ -q # Python unit testsLive smoke (requires SketchUp running with the extension started)
uv run python examples/smoke_check.py # 26-step end-to-end
uv run python examples/smoke_multi_client.py # concurrent multi-clientFor a split-host setup (e.g. Linux dev box + Windows SketchUp), run the smokes on the Linux side. The file export_scene writes in step 18 of smoke_check.py then lands on the SketchUp machine, so that step only asserts that a path came back. Two ways to reach SketchUp:
SSH tunnel (preferred, see Security model): the host stays
127.0.0.1, so the script cannot tell that SketchUp is remote. RunSKETCHUP_MCP_SMOKE_REMOTE=1 uv run python examples/smoke_check.py; without the variable step 18 looks for the export file on the Linux machine and fails.smoke_multi_client.pyneeds nothing extra.LAN address: prefix either script with
SKETCHUP_MCP_HOST=<sketchup-host>. A non-loopback host is recognized as remote on its own. The plugin has to listen on that address, with the risks described in the Security model.
Troubleshooting
SketchUp not running or extension not started: ...
The Python MCP server connected to the configured host/port but found nothing listening. Either:
SketchUp isn't running, or
The extension is installed but not started — open
Plugins → MCP Server → Start Server.
The Python server stays alive after this error; the next tool-call retries the connect.
IncompatibleVersionError
One side is older than the other accepts. The message names the outdated side and the minimum version it needs:
Client too old — upgrade the Python package: run
uvx sketchup-mcp2@latestonce (oruv pip install -U sketchup-mcp2for a pip install), then restart your MCP client. A plainuvx sketchup-mcp2keeps running its cached version.Plugin too old — install the latest
.rbzfrom GitHub Releases.
Each side declares only the oldest counterpart it works with, so being newer never fails the handshake. Releases up to 0.3.1 are the exception: they accept only a counterpart of their own version, so moving past 0.3.1 means upgrading both once. The floors live in src/sketchup_mcp/compat.py (MIN_RUBY) and mcp_for_sketchup/mcp_for_sketchup/core/compat.rb (MIN_PYTHON).
Tool-call timeouts on long operations
Bump SKETCHUP_MCP_TIMEOUT in your .mcp.json env block. Default is 60 seconds. Keep it well above 30 s: a chamfer or fillet call starts no new cut after 30 s inside SketchUp and then rolls back, and a client that gives up sooner can walk away from an edit that still commits.
SketchUp does not learn that the client gave up. After a timed-out call that changes the model, check the model with get_component_info or list_components before retrying — a blind retry can apply the edit twice (a double chamfer). The error message says the same. Read-only calls are safe to repeat.
SketchUp UI freezes during big requests
Frame-decoding is capped at 50 reads × 64 KiB per client per tick (~3.2 MB) to keep the UI responsive, but a very large eval_ruby body or a runaway loop inside it will still freeze SketchUp until it returns. Break the work into smaller calls if you can.
MCP client reports connection timed out after 30000ms at startup
If the client can't connect but SketchUp itself is reachable (e.g. telnet <host> 9876 succeeds), the bottleneck is the Python server's own startup, not the link to SketchUp.
The usual culprit is running the server from a source checkout whose virtual environment lives on a slow filesystem — VMware Shared Folders (vmhgfs-fuse), VirtualBox shared folders, NFS/CIFS network drives, or WSL's /mnt/.... Python touches hundreds of small files at startup, and importing the FastMCP dependency stack from such a filesystem can take 30 s+ — past the client's init timeout. (A quick check: time uv run python -c "import sketchup_mcp.app" — if that takes tens of seconds, the filesystem is the problem.)
Keep the virtualenv on a local disk. With uv, point it there via UV_PROJECT_ENVIRONMENT in the server's .mcp.json env block — the project source can stay on the shared folder (it's small, and editable installs pick up changes live); only the dependency-heavy venv needs to be local:
"sketchup": {
"command": "uv",
"args": ["run", "--directory", "/path/to/sketchup-mcp2", "python", "-m", "sketchup_mcp"],
"env": {
"UV_PROJECT_ENVIRONMENT": "/home/you/.venvs/sketchup-mcp2",
"SKETCHUP_MCP_HOST": "127.0.0.1"
}
}The uvx sketchup-mcp2 setup shown earlier isn't affected — uvx already keeps its environment under uv's local cache.
Why is the venv on a shared folder at all? This bridge is typically run in an isolated VM setup — both Claude Code launched with
--dangerously-skip-permissionsandeval_ruby(arbitrary Ruby, full filesystem/shell access) enabled are risky enough to want a disposable VM. Typical layout: a Linux VM (Claude Code + MCP server) ↔ a Windows VM (SketchUp) connected through the SSH tunnel described in Security model, project on a host-shared folder — which is exactly why theUV_PROJECT_ENVIRONMENTnote above matters.
License
MIT — see LICENSE.
Credits and attribution
Originally forked from mhyrr/sketchup-mcp. The fork diverged at v0.0.1 with a new wire protocol (4-byte length-prefix framing, JSON-RPC 2.0 envelopes), modular handler architecture, expanded introspection / joinery / edge-op tools, multi-client server with one-time
hellohandshake, MCP prompt, viewport screenshot, settings dialog, and full unit-test coverage on both Ruby and Python sides.Published to PyPI as
sketchup-mcp2; the upstream package issketchup-mcp.Bridge-pattern inspiration from ahujasid/blender-mcp.
Contributing
Pull requests welcome. Before opening one, please run both test suites (ruby test/run_all.rb and uv run pytest tests/) and — if you've touched anything in the IO path — the live smokes against a running SketchUp.
Available Tools
22 toolsboolean_operationA
Perform a boolean operation (union / difference / intersection) on two solids.
difference = target minus tool. Operating on an instance of a shared definition consumes only that instance — the result is a new group, sibling instances are untouched. Unreliable on non-manifold geometry.
Returns: JSON {id, name, type, bbox_mm{min,max}|null}. Read bbox_mm to verify the result; it is null for empty geometry (e.g. a difference that consumed the whole body).
Inputs: tool_id (required), target_id (required), operation, delete_originals. Returns: result
chamfer_edgeA
Chamfer (bevel) every feature edge of a group/component by distance mm.
Seams of curved surfaces — edges where the surface bends by less than 25° (the two face normals differ by under 25°), such as a cylinder's vertical facet edges or every edge of a sphere — are skipped; the rims of curved surfaces are chamfered segment by segment. Concave (inside-corner) edges, such as the base of a post or the inner corner of an L-shaped block, are skipped too: chamfering them would need added material. A body with no feature edges fails with -32602, as does an inside-out body (faces pointing inward): reverse its faces first. A call starts no new cut after 30 s inside SketchUp and then rolls back, changing nothing. Unreliable on non-manifold geometry.
Returns: JSON {id, name, type, bbox_mm|null, edges_chamfered, stats{attempted, succeeded, subtract_failed, skipped_no_match, skipped_seam, skipped_concave, skipped_curved}} — check stats.subtract_failed == 0 (failed cuts) and stats.skipped_no_match == 0 (edges consumed by earlier cuts).
Inputs: id (required), distance. Returns: result
create_componentA
Create a primitive (cube / cylinder / cone / sphere) in SketchUp.
All linear values are millimeters (mm). Minimum size per dimension: 0.1 mm for cube (thin stock like veneer is fine), 1.0 mm for sphere / cylinder / cone (tessellated types degenerate earlier). position is the bounding-box MIN corner (not the center); the same anchor is used by transform_component.position. Per-type dimensions: cube uses [x, y, z]; cylinder and cone use [0]=diameter, [2]=height ([1] is ignored); sphere uses [0]=diameter only. New geometry is wrapped in a SketchUp Group.
Returns: JSON {id, name, type, bbox_mm{min,max}|null}. Read bbox_mm to verify the result before the next step.
Inputs: name, type, position, dimensions. Returns: result
create_dovetailA
Create a dovetail joint between two boards.
All dimensions in millimeters; angle is in degrees, valid range (0, 60]. Offsets shift the joint from the board face's center. Defaults are sized for ~100 mm boards. The two boards must already touch/overlap along the joint axis.
Returns: JSON {tail: {id, name, type, bbox_mm|null}, pin: {...}, boolean_cuts: {attempted, failed}} — non-zero failed means some cuts did not apply (likely non-manifold geometry); verify via bbox_mm.
Inputs: pin_id (required), tail_id (required), angle, depth, +6 more. Returns: result
create_finger_jointA
Create a finger joint (box joint) between two boards.
All dimensions in millimeters; offsets shift the joint from the board face's center. Defaults are sized for ~100 mm boards. The two boards must already touch/overlap along the joint axis.
Returns: JSON {board1: {id, name, type, bbox_mm|null}, board2: {...}, boolean_cuts: {attempted, failed}} — non-zero failed means some cuts did not apply (likely non-manifold geometry); verify via bbox_mm.
Inputs: board1_id (required), board2_id (required), depth, width, +5 more. Returns: result
create_layerA
Create a new layer (tag) with the given name.
Returns: JSON {id, name, visible}.
Inputs: name (required). Returns: result
create_mortise_tenonA
Create a mortise-and-tenon joint between two boards.
All dimensions in millimeters; offsets shift the joint from the board face's center. Defaults are sized for ~100 mm boards. The two boards must already touch/overlap along the joint axis.
Returns: JSON {mortise: {id, name, type, bbox_mm|null}, tenon: {...}, boolean_cuts: {attempted, failed}} — non-zero failed means some cuts did not apply (likely non-manifold geometry); verify via bbox_mm.
Inputs: tenon_id (required), mortise_id (required), depth, width, +4 more. Returns: result
delete_componentA
Delete a group or component instance by entity ID. Raw faces, edges and other entities fail with -32602.
Returns: JSON {ok: true}.
Inputs: id (required). Returns: result
eval_rubyA
Evaluate arbitrary Ruby code in SketchUp.
Enabled by default; the user can close the gate in the SketchUp
extension's Settings. When closed, the SketchUp side returns JSON-RPC
code -32010 with a user-facing message explaining how to re-enable it.
This wrapper surfaces that message as a plain string so the LLM can
repeat it to the user verbatim — without the [code] prefix that
format_error would otherwise add.
Returns the .to_s of the LAST evaluated expression; stdout (puts) is NOT
captured. End scripts with an explicit expression — e.g. a final
result.to_json — to get structured data back. Errors return
"[code] message" with the Ruby exception class and message.
Inputs: code (required). Returns: result
export_sceneA
Export the current scene to a temp file on the SketchUp host.
Formats: skp (native), obj / dae / stl (geometry), png / jpg (viewport render, default 1920×1080). The file is written on the machine running SketchUp — on a split-host setup the path is not directly readable here. An untitled model cannot be exported to skp (-32602) — the user must save it first; other formats work.
Returns: JSON {path, format}.
Inputs: format. Returns: result
fillet_edgeA
Round (fillet) every straight feature edge of a group/component by
radius mm with segments arc segments.
Skips seams of curved surfaces (edges where the surface bends by less than 25°: the two face normals differ by under 25°) and the rims of curved surfaces, such as a cylinder's top and bottom circles: fillet cannot round a tessellated curve. Also skips concave (inside-corner) edges, such as the base of a post or the inner corner of an L-shaped block: rounding them would need added material. A body with no straight feature edges (cylinder, cone, sphere) fails with -32602, as does an inside-out body (faces pointing inward): reverse its faces first. A call starts no new cut after 30 s inside SketchUp and then rolls back, changing nothing. Unreliable on non-manifold geometry.
Returns: JSON {id, name, type, bbox_mm|null, edges_filleted, stats{attempted, succeeded, subtract_failed, skipped_no_match, skipped_seam, skipped_concave, skipped_curved}} — check stats.subtract_failed == 0 (failed cuts) and stats.skipped_no_match == 0 (edges consumed by earlier cuts).
Inputs: id (required), radius, segments. Returns: result
find_componentsA
Find components matching name substring, layer, and/or type.
Name matching is case-insensitive substring; layer must match exactly. Searches recursively (bounded by max_depth). With no filters it returns all components up to max_depth (paginated) — same traversal as list_components.
Returns: JSON {components[], total, offset, truncated} — if truncated, request the next page with offset += limit.
Inputs: name, type, layer, limit, +3 more. Returns: result
get_component_infoA
Detailed info for a single group or component instance by entity ID.
Returns: JSON {id, name, type, layer, depth, bbox_mm|null}.
Inputs: id (required). Returns: result
get_model_infoA
Get current SketchUp model info: file path, title, units, bounding box, entity count, layer list.
Returns: JSON {path, title, units: "mm", bounding_box_mm|null, entity_count, layers[]}.
Inputs: no named parameters. Returns: result
get_selectionA
Get the entities currently selected in the SketchUp UI.
Returns: JSON {entities: [...]} — groups/components are {id, name, type, layer, depth, bbox_mm|null}; other selected entities (edges, faces, ...) are {id, type} only.
Inputs: no named parameters. Returns: result
get_versionA
Return the server version and Python↔Ruby compatibility verdict.
Useful as a runtime sanity probe — always returns a payload, even when the connection or other tools surface errors. The result is a JSON string with fields: python_version, ruby_version, min_compatible_ruby, ruby_min_compatible_python, compatible (bool), error (string | null).
Inputs: no named parameters. Returns: result
get_viewport_screenshotA
Capture the current SketchUp viewport; returns the PNG image plus a JSON text block {width, height, preset_used, style_used}.
Useful for letting Claude visually verify the scene between steps.
Parameters
max_size: largest side of the returned PNG (64..4096). Aspect ratio is taken from the current viewport; the smaller side is scaled proportionally.
view_preset: switch the camera to a standard view before snapping.
currentleaves the camera alone.zoom_extents: call view.zoom_extents before snapping.
style: temporarily flip a small set of rendering_options keys.
defaultleaves them alone.restore_view: when true (default), camera and rendering_options are snapshotted before mutation and restored after the snapshot, so the user's viewport is unchanged.
If the connection drops mid-response the call is retried automatically; the viewport may briefly flicker in that rare case.
Inputs: style, max_size, view_preset, restore_view, +1 more.
list_componentsA
List groups and component instances in the model (paginated).
Each component is {id, name, type, layer, depth, bbox_mm} (detailed) or {id, name, type, layer, depth} (concise); bounds are world-coordinate mm. Set recursive=true to descend into nested components (bounded by max_depth, default 3).
Returns: JSON {components[], total, offset, truncated} — if truncated, request the next page with offset += limit.
Inputs: limit, offset, max_depth, recursive, +1 more. Returns: result
list_layersA
List all model layers (tags).
Returns: JSON {layers: [{name, visible, color, id}]}.
Inputs: no named parameters. Returns: result
set_materialA
Assign a material (color) to a group, component instance, face or edge.
material: a material already in the model, matched by name without regard to case, is used as is (so an existing "Red" is used for "red"). Otherwise a named color — red, green, blue, yellow, cyan, turquoise, magenta, purple, white, black, brown, wood, orange, gray, grey — or a 6-digit hex string like "#a05030" (#rrggbb), in any case, maps to one lower-case material, found or created. Anything else fails with -32602. Painting a group/component affects only this instance (it is made unique first); painting a raw face/edge id (obtainable via get_selection) colors the shared definition — all instances show it.
Returns: JSON {id, name, type, bbox_mm{min,max}|null}. For a face or edge, type is "face" or "edge" and name is null.
Inputs: id (required), material (required). Returns: result
transform_componentA
Move, rotate and/or scale a group or component (mm / degrees).
Groups and component instances only; other entities fail with -32602.
position: ABSOLUTE target for the entity's bounding-box MIN corner, in mm — the same anchor create_component uses. Applied LAST (after rotation/scale), so the final bbox-min lands exactly at [x, y, z] even in combined calls. It is NOT a relative offset: repeating the same position is idempotent.
rotation: RELATIVE rotation in degrees around the bbox center, applied sequentially about world X, then Y, then Z.
scale: RELATIVE scale factors about the bbox center.
These validations (3-element lists, non-zero scale) apply only to this typed tool — raw Ruby driven through eval_ruby bypasses them.
Returns: JSON {id, name, type, bbox_mm{min,max}|null}. Read bbox_mm to verify the result; it is null for empty geometry.
Inputs: id (required), scale, position, rotation. Returns: result
undoA
Undo the last atomic operation in SketchUp. One MCP tool-call = one undo step.
Returns: JSON {ok: true}.
Inputs: no named parameters. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 22 tools
Each tool targets a clear resource+action (create primitive, transform, boolean, joints, chamfer/fillet, query, export, screenshot). The only real overlap is list_components vs find_components, since find_components with no filters reproduces the same traversal as list_components; descriptions distinguish them but an agent could still pick the wrong one.
Strong verb_noun snake_case pattern throughout (create_component, transform_component, get_model_info, list_layers, chamfer_edge, create_dovetail, etc.). Minor deviations: the bare 'undo' and the noun-style 'boolean_operation' break the pattern slightly, but the convention is otherwise predictable.
22 tools is on the heavier side, but the domain is broad (primitive creation, joinery, mesh ops, queries, export, viewport, Ruby escape hatch) and nearly every tool earns a distinct slot. It stays within a reasonable envelope rather than sprawling into redundant duplicates.
Covers the full lifecycle: create (primitive/joint/layer), transform, material, boolean, chamfer/fillet, delete, list/find/info, export, screenshot, undo. Gaps are minor — no layer delete/rename or material removal — and eval_ruby provides an escape hatch for anything missing.
Maintenance
Related MCP Connectors
Connect ChatGPT and Claude to your Mac, Windows or Linux with secure MCP remote access.
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
Connect your AI assistant to Blender for 3D modeling, Geometry Nodes, materials, lighting, animation, rendering and export. Inspect real scenes and viewport images, refine the result and restore checkpoints. OAuth connects your chat to Blender Bridge Desktop on an online Windows 10/11 x64 computer running Blender 4.2+. The chat can run on another device. Requires an active Blender Bridge account; 7-day trial available. AI model access is separate.
Persistent context for Claude. Your AI always knows your projects and next actions across sessions.
Related MCP Servers
- AlicenseBqualityDmaintenanceConnects Sketchup to Claude AI through the Model Context Protocol, allowing Claude to directly interact with and control Sketchup for prompt-assisted 3D modeling and scene manipulation.10545MIT
- AlicenseBqualityDmaintenanceIntegration that connects Sketchup to Claude AI through the Model Context Protocol, allowing Claude to directly interact with and control Sketchup for prompt-assisted 3D modeling, scene creation, and manipulation.1028MIT
- AlicenseBqualityDmaintenanceEnables direct interaction and control of SketchUp through Claude AI using the Model Context Protocol and a TCP socket connection. It allows for prompt-assisted 3D modeling, component manipulation, and the execution of arbitrary Ruby code within the SketchUp environment.101MIT
- AlicenseAqualityDmaintenanceConnects Claude AI to SketchUp, allowing you to create and modify 3D models via natural language commands.217MIT