The room layout is approved when the client asks for three finish options: light oak, dark walnut, and painted cabinetry. They also want each option shown from the same two angles. It sounds like a quick material change, until editing one cabinet affects every matching component or the exported views no longer line up.

Using SketchUp with Claude can help organize this work, but it requires more than asking for a Ruby script. A community-built SketchUp MCP connector can give Claude structured access to a running desktop model. Depending on its tools, Claude can inspect components, apply materials, execute Ruby, and export views. With Computer Use available and approved, it can also navigate the interface to check selections, presentation settings, and visible results. These are separate access methods, not native SketchUp features.

This guide follows one interior model through three finish alternatives and a consistent comparison set. You will connect Claude, inspect the model before editing, protect shared components and materials, and verify the exported images. The aim is a repeatable presentation workflow that preserves the original design and keeps consequential changes under your control.

Source: SketchUp Help

Choose the Right Kind of Access

For our interior presentation, Claude needs two kinds of information: what the model contains and how the proposed changes look. A component inventory can identify repeated cabinetry, but it cannot establish whether the wood grain looks convincing from the presentation angle. A screenshot can reveal that problem without explaining which material assignment caused it.

Choose the access method around the task:

The SketchUp MCP project used here connects a Python server to a Ruby extension running inside desktop SketchUp. This is not a setup for SketchUp Web. Keep the desktop application open with the intended model loaded before testing the connection.

We will use Claude Desktop as the main MCP client. Where a dedicated connector tool covers the task, prefer it over unrestricted Ruby execution. Changing a component’s color should not require a script that also reorganizes the model or accesses unrelated files.

For Computer Use, use an eligible Cowork or Claude Code session in the desktop app and approve access to SketchUp when requested. Do not assume a local MCP configuration is automatically available in every Claude session.

Start with a narrow instruction: inspect the active model, identify the cabinetry targeted for alternatives, and report the proposed approach. Do not change geometry, materials, or files yet. That gives you a chance to verify both the connection and Claude’s interpretation of the task.

Connect Claude to a Running SketchUp Model

The connection uses two processes: an extension inside SketchUp receives commands, while a Python MCP server exposes tools to Claude. Both must be available. A server appearing in Claude’s tool list does not prove that it can reach the intended SketchUp model.

Use the installation instructions for the selected sketchup-mcp2 connector, rather than combining setup files from similarly named projects.

1. Install the SketchUp Extension

Download the project’s .rbz package from its releases, or follow its packaging instructions if a release package is unavailable. In SketchUp, open Extension Manager, choose Install Extension, and select that file. Restart SketchUp as instructed.

Source: SketchUp Help

This is third-party code running inside your modeling application. Review the project and test it with a copy of a non-sensitive model before using it on client work.

The extension includes an Enable Ruby evaluation setting. Leave it disabled for the initial connection test. Dedicated inspection tools do not require granting Claude unrestricted Ruby execution.

2. Start the Bridge

Open Plugins → MCP Server → Start Server. The documented default address is 127.0.0.1:9876.

Keep that loopback address for a same-computer setup. Do not expose the bridge to your network simply to resolve a connection problem. Claude, the Python server, and SketchUp should initially run on the same machine.

3. Add the MCP Server to Claude Desktop

Install uv if needed, then open Claude Desktop’s developer configuration and add the server entry:

{
  "mcpServers": {
    "sketchup": {
      "command": "uvx",
      "args": ["sketchup-mcp2"]

{
  "mcpServers": {
    "sketchup": {
      "command": "uvx",
      "args": ["sketchup-mcp2"]

Merge this entry with any existing configuration rather than replacing other servers. If Claude cannot locate uvx, use its actual absolute executable path. Fully restart Claude Desktop after saving.

Keep the Python package and Ruby extension on compatible versions. The connector documents a version handshake, so a mismatch should be resolved before testing edits.

4. Confirm the Model Without Changing It

Ask Claude:

Read the SketchUp version and active model information. List the top-level components and current selection. Do not create, modify, delete, or export anything.

Check the response against your open model. If the connection fails, verify the bridge, matching port, and package versions first.

The connector also documents a viewport screenshot tool requiring SketchUp 2026 or later. That tool returns an image; it does not grant mouse-and-keyboard control. Computer Use remains a separate setup.

Inspect the Model Before Changing Its Appearance

Before Claude prepares finish alternatives, establish exactly which parts of the model can change. “Make the cabinetry darker” is ambiguous if the room contains nested cabinet components, separate door faces, and materials shared with other furniture.

Start by saving a working copy of the original .skp file. Then select the intended cabinetry in SketchUp and ask Claude to inspect that selection. Component names are useful, but names alone may not uniquely identify an object. Combine them with its hierarchy, location, and dimensions.

Source: SketchUp Help

The inspection should answer four questions:

• Scope: Which groups or component instances belong to the finish change?

• Reuse: Do those instances share definitions with objects elsewhere?

• Materials: Are finishes assigned to the container, internal faces, or both?

• Baseline: Which file, units, and existing scenes define the approved design?

Identify the Editing Context

A selection inside an open component is not equivalent to selecting that component from the top level. Claude should report the active editing context before proposing changes.

Where connector inspection is insufficient, a reviewed, read-only Ruby API query can provide additional information:

This example does not modify the model. However, running it through eval_ruby requires that capability to be deliberately enabled and the call approved.

Check dimensions separately. The connector documents millimeters for its geometry tools, while direct Ruby operations follow SketchUp’s unit conventions. Display units do not automatically determine how numeric API inputs are interpreted.

Finish with a proposed change list, not an edit. If Claude cannot distinguish the target cabinets from repeated instances, clarify the selection before proceeding. A small ambiguity at this stage can become a model-wide material change later.

Build Finish Alternatives Without Changing Everything Else

With the target cabinetry identified, create the first alternative in a separate working file. Keep the approved geometry, component positions, and presentation settings unchanged. The initial task is a finish variation, not a redesign.

Before applying a material, determine where the current finish is assigned. SketchUp supports materials on individual faces and on group or component containers. These assignments do not behave identically. Default-material faces can inherit a container’s material, while explicitly painted faces retain their own assignments. The official material application guide explains these distinctions.

If changing the cabinet container’s color appears to do nothing, do not immediately repaint every nested face. Inspect the existing assignments first.

Source: SketchUp Help

Separate Component Changes From Material Changes

Two forms of sharing can affect the result:

• Shared component definitions: Editing geometry or face assignments inside a definition can affect its other instances.

• Shared materials: Editing an existing material changes its appearance wherever that material is used.

These require different precautions. Make Unique separates a component instance from its original definition. It does not automatically duplicate every material used inside it.

Source: SketchUp Help

For an isolated finish alternative, Claude may need both a unique component definition and a separately named material. However, making every cabinet unique is unnecessary if the intention is to update all matching cabinets together. Agree on the scope before breaking useful relationships.

Prepare three alternatives: Light Oak, Dark Walnut, and Neutral Painted Finish. Use verified texture assets where required. The connector’s dedicated set_material tool documents color assignment, so do not assume it also configures texture mapping or a complete photoreal material. More advanced material work may require reviewed Ruby or interface operations.

Source: SketchUp Help

Scenes Are Viewpoints, Not Material Backups

SketchUp scenes can preserve camera position, visibility, styles, shadows, and other presentation properties. They do not provide independent snapshots of material assignments.

Creating an “Oak” scene and a “Walnut” scene will not, by itself, switch the cabinetry between those finishes. For this walkthrough, keep separate .skp files derived from the same baseline. Each file should retain the same two presentation scenes.

Source: SketchUp Help

Give Claude a bounded instruction:

Prepare the Light Oak alternative in a new working file. Change only the approved cabinetry finishes. Identify shared definitions and materials before editing, and explain any required duplication. Preserve geometry, dimensions, camera scenes, and unrelated furniture. Ask before enabling Ruby evaluation or overwriting a file.

Inspect the first alternative before creating the others. That establishes whether the material scope is correct and gives subsequent versions a reliable process to follow.

Use Computer Use to Catch What the Model Report Misses

A model report can confirm that a material was assigned, but the presentation may still show an unchanged cabinet door or wood grain at an unrealistic scale. Computer Use helps connect the model’s technical state with what a client will actually see.

In an eligible Claude session, enable Computer Use and approve access to SketchUp. Begin with inspection rather than editing. Give Claude a specific view, target, and stopping point.

Verify the Editing Context

Ask Claude to inspect the selected cabinetry using the selection highlight, Entity Info, and Outliner where available. It should distinguish between selecting the whole cabinet and selecting a face inside an open component.

A useful instruction is:

Inspect the selected cabinet and its editing context. Confirm whether the selection matches the approved finish scope. Do not enter another component, repaint surfaces, or save the model.

This catches mistakes that a name-based operation can miss. If the wrong object is selected, correct the target before requesting further changes. Do not let visual similarity stand in for a verified component identity.

Source: SketchUp Help

Compare Finishes From the Same View

Open the same presentation scene in each alternative file. Ask Claude to inspect texture direction, apparent scale, inconsistent door finishes, and surfaces that still show the baseline material.

For example, a wood texture might run vertically on one door and horizontally on its neighbor. That is a targeted mapping problem, not a reason to replace the entire material library.

Keep the camera and presentation settings fixed during the comparison. Otherwise, differences in framing or shadows can make one finish look better for reasons unrelated to the finish itself. Treat Claude’s observations as review assistance, not automatic design approval.

Recover a Presentation View

Missing geometry may be hidden by a tag, an active section plane, or a saved scene setting rather than deleted. Ask Claude to inspect those controls before attempting a repair.

Avoid broad instructions such as “unhide everything.” They can expose working geometry and clutter the intended presentation. Instead, identify the missing object, check its visibility and section context, then propose the smallest correction.

After an approved interface change, verify the result and deliberately update the relevant scene if needed. Navigating to a better-looking view does not automatically preserve it for the next export.

Source: SketchUp Help

Export a Comparison Set the Client Can Actually Use

With all three finishes approved, turn the alternatives into a consistent presentation set. Use the same two saved scenes in each file, such as an entry view and a cabinetry detail. This produces six images without introducing new camera decisions during export.

Before exporting, agree on image dimensions, file format, background treatment, and destination folder. Keep the style, shadows, and camera framing consistent across the alternatives. If a scene does not save one of these properties, check it explicitly rather than assuming that switching scenes restores everything.

Source: SketchUp Help

Export the View, Then Inspect the File

For native presentation images, SketchUp’s 2D Graphic export supports raster formats including PNG and JPEG. Its options control dimensions and settings such as anti-aliasing.

Use this sequence for each alternative:

1. Open the correct working file and confirm its finish.

2. Select the intended saved scene and check the framing.

3. Export using the agreed settings and a unique filename.

4. Open the exported image and compare it with the intended view.

Do not treat a viewport screenshot as an interchangeable final export. Screenshots can contain selection highlights or interface elements, and their resolution depends on the captured display. The exported file needs its own review.

Ask Claude to record the model filename, alternative, scene name, export dimensions, and output path. A successful tool response or export dialog closing is not sufficient proof that the correct deliverable exists. Verify the actual file and its contents.

Keep Native Exports Separate From Renderer Outputs

A SketchUp viewport image is not the same deliverable as a V-Ray or Enscape render. Those applications introduce their own materials, lighting, output settings, and completion checks. The MCP connector’s generic export capability does not establish control over a renderer’s production workflow.

Keep this walkthrough focused on native comparison images. If photoreal rendering is required, make it a separately approved stage using the installed renderer’s supported controls.

Finish by reviewing all six images together. Confirm that their angles match, filenames identify the options, and no alternative accidentally shows the baseline finish. The package should make comparison straightforward, not require the client to interpret inconsistent views.

Keep Changes Reversible and Diagnose Narrowly

Save a checkpoint before each approved editing stage. Undo is useful for a recent model change, but it is not a replacement for separate working files or a reliable way to recover overwritten exports.

SketchUp’s Ruby API provides operations that group edits into undoable steps. The connector documents this behavior for its mutating handlers. Custom Ruby needs the same deliberate treatment: a script should have a clear scope, appropriate operation handling, and a recovery plan.

When something goes wrong, identify the affected layer before trying another action.

Treat Ruby Access as a Separate Decision

The connector’s eval_ruby capability can execute arbitrary Ruby inside SketchUp. That is more authority than a dedicated material or inspection tool. Enable it only when needed, review the proposed code, and retain approval prompts.

Keep the bridge on its local loopback address for this setup. Do not expose it publicly to connect another machine. A network-accessible bridge with code execution requires stronger protection than this walkthrough provides.

Avoid automatic cleanup operations such as deleting unused components, purging materials, or replacing extensions while troubleshooting a presentation problem. They can affect assets unrelated to the current task.

Make one targeted correction, inspect the result, and record what changed. If the outcome remains unclear, return to the checkpoint rather than stacking further edits onto an uncertain model state.

Work With Larger SketchUp Projects on Vagon

An interior model can become demanding long before the design is finished. Detailed furniture, high-resolution textures, and repeated components add to the workload. If navigating the model or switching presentation views feels sluggish, preparing several finish alternatives becomes harder to review efficiently.

Vagon Cloud Computer gives you access to a cloud workstation from your existing device. You can install SketchUp and the tools your project needs, then choose available performance options suited to the workload. That gives you another way to handle demanding projects without making a workstation purchase the prerequisite for your next client presentation.

For this workflow, keep SketchUp, Claude Desktop, and the MCP server on the same cloud computer. The local bridge then connects within that workstation, while you access it remotely. Your original model, alternative files, and exported images can stay together in one working environment.

Choose resources around the task rather than assuming that every SketchUp operation benefits equally from a larger GPU. Model editing and Ruby execution do not scale in the same way as GPU rendering. If you add a renderer, check its supported hardware, licensing, and memory requirements separately.

The practical opportunity is to give a complex project more room: work with detailed assets, compare finishes in the full model, and prepare presentation outputs without tailoring every decision to your laptop’s limits. Test a representative model before committing to a larger production run.

With the environment ready, use Claude for controlled edits and review assistance, and Vagon for the computing capacity behind the project. Keep checkpoints and approval boundaries in place as you scale.

FAQs

Can Claude Edit an Existing SketchUp Model?

Yes, with a compatible connection and supported tools. The SketchUp MCP connector used here can inspect model information and perform documented edits. More complex changes may require reviewed Ruby execution. Start with a working copy, identify the target objects, and ask Claude to explain the proposed scope before applying changes.

Is There an Official SketchUp MCP Integration?

The connector in this guide is a community project, not a native SketchUp feature or a Trimble-supported integration. Its capabilities, compatibility, and installation instructions come from its maintainers. Evaluate the extension and Python package together, keep their versions compatible, and test them on a non-sensitive model before introducing client files.

Does This Setup Work With SketchUp for Web?

The MCP setup described here requires an extension running inside desktop SketchUp. It is not a connection method for SketchUp Web. Browser-based interaction is a separate approach, using the web application’s available controls. Do not assume that desktop Ruby tools, extension menus, or export instructions apply unchanged to the browser version.

Do I Need Claude Code, or Can I Use Claude Desktop?

Claude Desktop can act as the MCP client for the setup shown here. Claude Code is another option, but its configuration should be handled separately. For screen interaction, use an eligible Computer Use session and approve access to SketchUp. Installing an MCP server does not automatically enable desktop control.

Can Claude Use SketchUp Without an MCP Server?

Yes, through Computer Use where available and configured. It can attempt interface tasks such as navigating panels, selecting scenes, and checking export settings. You can also ask Claude to write a Ruby script for manual review and execution. Neither approach provides the same structured tool access as MCP, and multi-step interface tasks still need verification.

Can Scenes Store Different Material Alternatives?

Not as independent snapshots of material assignments. SketchUp scenes preserve selected presentation properties, including camera position, visibility, styles, and shadows. Naming scenes after finishes does not make those finishes switch automatically. This guide uses separate model files for alternatives while retaining matching camera scenes in each.

Can Claude Control V-Ray or Enscape Through the Same Connector?

Do not assume so. Access to SketchUp’s model and Ruby API does not establish access to a renderer’s full workflow. Renderer control depends on its available APIs, integrations, interface controls, and version. Confirm support separately before asking Claude to change renderer materials, launch jobs, or manage output files. Native image export remains a distinct task.

How Do I Prevent Changes From Affecting Repeated Components?

Inspect both component definitions and shared materials before editing. Make Unique separates a component instance from its original definition, but it does not automatically isolate its materials. Create a separate material when necessary, confirm whether assignments belong to faces or containers, and test one target before extending the change.