# KeyShot MCP [Health: Active]

**Category:** 📐 Architecture & Design  
**Repository:** https://github.com/truman-t3/keyshot-mcp  
**GitHub Stars:** 25  
**npm Downloads (last month):** 750  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/keyshot-mcp

## Description
Control local KeyShot scenes, cameras, environments, and renders through headless scripting.

## Tools
Capabilities this server exposes over MCP:

- **keyshot_status** — Diagnose the local installation, output access, presets, bridge files, and a minimal KeyShot headless startup without modifying a user scene.
- **keyshot_product_render** — Run a complete product workflow in one headless process: open or import, assign materials, configure camera and environment, save a scene copy, and render one or all cameras.
- **keyshot_inspect_scene** — Open a scene read-only and return metadata, objects, cameras, material assignments, model sets, and external references.
- **keyshot_list_cameras** — Return saved camera names without saving changes. Use this before selected-camera rendering when names are unknown.
- **keyshot_preview_render** — Render a bounded PNG preview from an existing scene and return it directly as MCP image content. Temporary previews are deleted after embedding; an optional safe output path preserves a copy.
- **keyshot_sync_saved_scene** — Find a saved .bip file (or the newest .bip in one folder), detect whether it changed, copy it to a collision-safe output path, and optionally return an Agent-visible preview. This is the stable alternative to unsupported persistent GUI control.
- **keyshot_render** — Render the active or a named camera from an existing scene to an image file.
- **keyshot_render_queue** — Render independent scene and camera jobs sequentially so KeyShot processes do not compete for a license or output files.
- **keyshot_batch_render** — Render an explicit list of saved cameras from one scene into an output directory.
- **keyshot_render_all_cameras** — Discover every saved camera and render each view in one headless process with collision-safe file names and per-camera results.
- **keyshot_import_model** — Import a supported local model into an empty or base scene, apply requested composition options, and save a new scene.
- **keyshot_apply_material** — Apply a KeyShot library material or local material file to a specific object, then save the edited scene.
- **keyshot_list_material_presets** — Read the configured local material preset JSON and return valid preset names and material sources without opening KeyShot.
- **keyshot_apply_material_preset** — Resolve a configured material preset, apply it to one scene object, and save a new scene.
- **keyshot_set_camera** — Create or update a named camera using position, target, distance, field of view, or focal length, then save the edited scene.
- **keyshot_list_camera_presets** — Read the configured camera preset JSON and return valid standard or absolute camera presets without opening KeyShot.
- **keyshot_apply_camera_preset** — Create or update a saved camera from a configured standard-view or absolute camera preset, then save the edited scene.
- **keyshot_set_environment** — Select an environment by library name or local file, optionally change brightness and rotation, and save the edited scene.
- **keyshot_save_scene** — Open an existing scene and save a copy to a requested path inside the configured safe output directory.

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

```json
"mcpServers": {
  "keyshot-mcp": {
    "command": "npx",
    "args": ["-y","keyshot-mcp"],
    "env": {
      "KEYSHOT_HEADLESS_EXE": ""
    }
  }
}
```

**Requires environment variables:** `KEYSHOT_HEADLESS_EXE` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What KeyShot MCP MCP server does

KeyShot MCP MCP server lets an MCP-compatible agent work with saved KeyShot scenes through local headless scripting. It can inspect scene metadata, objects, cameras, materials, model sets, and references; import models; apply named materials or local material files; and save an existing scene to a controlled output path.

Rendering workflows can use a selected or active camera, every saved camera, a chosen group of cameras, or a sequential queue of independent jobs. The server also supports preview renders that return PNG content to the agent for visual review. A product-render workflow can prepare a scene, save a copy, and render it in one KeyShot process.

The server works with saved files rather than the live KeyShot window. It does not read edits that have not been saved in the scene file, and it does not provide real-time GUI control.

## How it works

The KeyShot MCP MCP server runs on the same computer as KeyShot and starts KeyShot in headless mode. An agent calls the available MCP tools, which perform operations against saved scenes and configured output locations. The status tool checks local configuration, output access, presets, and whether KeyShot can start with the configured setup.

A typical workflow begins with status and scene inspection. The agent can then adjust a selected object’s material, create or update a camera, choose an environment, and request a preview. Temporary preview images are returned to the agent and removed after reading; a path can be supplied when a persistent image is required. After review, the agent can render the selected view or produce several views.

The sync workflow detects changes to a saved scene, copies the newest version safely, and returns a preview. Operations are intended to work on scene copies so the original saved scene is not overwritten by the normal product-render flow.

## Setup and configuration

The KeyShot MCP MCP server requires Node.js 20 or newer, an MCP-compatible client, and a locally installed, licensed KeyShot edition that supports headless scripting. The documented tested environment is Windows 11 with KeyShot Studio 2025 or KeyShot 14.1.

Install the npm package with `npx -y keyshot-mcp@0.13.5`, or install it globally and use the `keyshot-mcp` command. A source build is also supported with pnpm, followed by running the generated `dist/index.js` with Node. Configure `KEYSHOT_HEADLESS_EXE` with the full path to the local `keyshot_headless.exe`.

After adding the server to the client’s MCP configuration, restart or reload the client and call `keyshot_status`. A successful setup reports `ready: true` after checking the executable, output access, bridge, presets, and a minimal KeyShot startup. KeyShot software, licenses, and library assets are not bundled with the server.

## Tools and capabilities

The documented tools cover these areas:

- Diagnose executable, output, preset, bridge, and startup configuration.
- Inspect scenes and list saved cameras, camera presets, and material presets.
- Import models into an empty or base scene and save the result.
- Apply materials by KeyShot material name, local file, or configured preset.
- Create or update camera transforms, distance, field of view, or focal length.
- Select or adjust an environment, including brightness and rotation.
- Produce previews, single-camera renders, batch camera renders, all-camera renders, and queued jobs.
- Copy changed saved scenes, save scenes, and run combined product-render workflows.

## Limitations and notes

Results returned by tools, including scene information and previews, are delivered to the MCP client’s agent. Depending on that client’s implementation and model configuration, the content may be sent to the selected model provider. The server itself does not upload this material, but confidential projects should be reviewed against the project’s privacy and security requirements.

The server depends on a valid local KeyShot installation and headless scripting support. Because it operates on saved scenes, users must save changes before asking the agent to inspect or synchronize them.

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