SketchUp MCP servers: what they are and how to set one up

What is MCP, in plain words?

MCP stands for Model Context Protocol. It is an open standard for plugging tools into AI apps, a bit like USB for AI. A program that offers tools is an MCP server. The AI app that uses them is the client.

Once a client knows about a server, the AI model can call its tools in the middle of a conversation: read a file, query a database, or talk to SketchUp. Most clients ask your permission before each tool call unless you tell them not to.

The point for SketchUp users: instead of copying code out of a chat window, the AI can act on your model directly and see what happened.

What a SketchUp MCP server does

Every local SketchUp MCP server works roughly the same way. An extension running inside SketchUp listens on your own computer (often on port 9876). The AI app connects to it and gets a handful of tools. Typical ones:

• Run Ruby: send code to SketchUp's Ruby API and get the result back. This is the tool that does most of the work, because the API can do almost anything you can do by hand.
• Inspect the model: list groups, components, materials, tags or the current selection.
• Screenshot: capture the viewport so the AI can look at what it built.
• Shortcuts for common jobs, such as making a box, moving a component or applying a material.

The agent works in a loop: look at the model, run some Ruby, read the result or the error, look again, adjust. That loop is what makes it more reliable than pasting a chatbot's script into the Ruby Console. It checks real names and real geometry instead of guessing.

Trimble's own connector for Claude also uses MCP, but differently. It runs a SketchUp session in Trimble's cloud and gives you a new .skp to download. It cannot open or edit a model you already have. If you want an agent working on your own file, you need a local server like the ones below. For where each kind of AI tool fits, see AI for SketchUp.

SketchUp MCP options

Open-source servers on GitHub

mhyrr/sketchup-mcp is the one most people find first. It is MIT licensed and has a short tool list: create, delete and transform components, set materials, export the scene, and eval_ruby for anything else. Its README names Claude as the client.

zinin/sketchup-mcp2 is a fork that has seen more work. It adds booleans, fillets and chamfers, joinery tools, an undo tool, a viewport screenshot on SketchUp 2026 and newer, and a settings switch to turn Ruby evaluation off. Each of its editing tools is wrapped as one undo step.

Both are free and both are maintained by volunteers, so features and activity change. Read the current README before you pick one.

Trimble's SketchUp connector

Official, hosted, and nothing to install. Good for a quick concept from a description or a reference image. Limited to Claude and to making new files, as above.

There is also MakeIt4Me, a paid local server. We make it; its section is below, and the comparison sets it against the free servers point by point.

How to set up a SketchUp MCP server

The exact steps depend on the project, but they follow the same pattern:

1. Check your SketchUp. You need desktop SketchUp Pro or Studio on Mac or Windows. SketchUp Free (web), SketchUp Go and the iPad app can't run extensions.
2. Install any tools the server needs. The Python-based servers use uv; the READMEs give the install command.
3. Install the extension. In SketchUp, open Extensions › Extension Manager, click Install Extension and pick the .rbz. Some servers ask you to restart SketchUp after this.
4. Start the server from the extension's menu, if it doesn't start on its own.
5. Register the server with your AI app. Add an entry to the app's MCP config, then fully quit and reopen the app.
6. Test it. With a model open, ask "What's in my open SketchUp model?" A working setup answers with real names from your file.

For Claude Desktop, the config file is opened from Settings › Developer › Edit Config (claude_desktop_config.json). An entry for a Python-based server looks like this:

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

Other clients keep the same mcpServers idea in their own file, or have a command for it (Claude Code has claude mcp add). If the agent can't see SketchUp, the usual causes are that SketchUp isn't running, the server wasn't started, or the app wasn't restarted after the config change.

Which AI apps can use a SketchUp MCP server?

Any MCP client that runs on the same computer as SketchUp. That includes Claude Desktop and Claude Code (see connecting Claude to SketchUp), Cursor, Windsurf, VS Code's agent mode, Gemini CLI and OpenAI's Codex. Newer desktop apps keep adding MCP support, so check your app's docs.

Two things rule some setups out. Chat apps in a browser (claude.ai, the ChatGPT website) and phone apps can't reach a server on your own computer. And the AI app needs to run where SketchUp runs, not on a different machine.

Your AI usage is billed by the AI provider as usual. The server itself doesn't add AI costs.

Is it safe? What to check first

A tool that runs Ruby in SketchUp can do anything Ruby can, including deleting geometry and writing files. That's what makes it useful, and why it's worth five minutes of checking:

• Undo. Does each change land as one step in Edit › Undo? Without that, a request that adds 200 pieces means 200 presses of Cmd+Z (Ctrl+Z on Windows), and a script that fails halfway leaves half a change behind.
• Read-only inspection. A good server lets the agent look without changing anything, and rolls back anything a look-only call did by accident.
• Local only. The server should listen on 127.0.0.1, not on your network. Most have no password.
• Source you can read. For an open-source server, skim the Ruby side. A search for start_operation tells you quickly whether it groups changes for undo.
• Approval prompts. Leave your client's per-tool approval on until you trust the setup.

In SketchUp's Ruby API, grouping a change into one undo step looks like this. If the code fails, abort_operation throws away the partial change:

model = Sketchup.active_model
model.start_operation("Paint walls", true)
begin
  model.entities.grep(Sketchup::Face).each { |f| f.material = "White" }
  model.commit_operation
rescue
  model.abort_operation
  raise
end

Whatever you use, save before a big request. Undo doesn't cover saves, exports or files written to disk, and File › Revert is the last resort if a session goes badly.

Questions