# DCC-MCP Core [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/dcc-mcp/dcc-mcp-core  
**GitHub Stars:** 54  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/dcc-mcp-core

## Description
Agent control plane for DCC and engine hosts: one MCP endpoint, one tool contract.

## Tools
Capabilities this server exposes over MCP:

- **ui_control__snapshot** — Capture a bounded PNG plus accessibility tree from the scoped application
- **ui_control__find** — Locate semantic controls by query, role, label, or object name
- **ui_control__act** — Perform one scoped semantic or coordinate-based action
- **ui_control__recording_start** — Start CUA trajectory/video recording in an absolute output directory
- **ui_control__recording_state** — Read current CUA recording state
- **ui_control__recording_stop** — Finalize CUA recording for later rendering
- **ui_control__wait_for** — Poll until a UI condition becomes true or times out
- **ui_control__stop_computer_use** — Release the capsule, hotkey, and global input owner

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

```json
"mcpServers": {
  "dcc-mcp-core": {
    "command": "uvx",
    "args": ["dcc-mcp-cli"]
  }
}
```

## Documentation

## What DCC-MCP Core MCP server does

DCC-MCP Core MCP server provides a shared control plane for agents working with desktop creative applications and related hosts. The repository describes adapters for DCC packages such as Maya, Blender, Houdini, 3ds Max, Cinema 4D, Nuke, and ZBrush, as well as engines, design tools, image and video applications, CAD tools, production tracking systems, and QA software.

The project standardizes how registered hosts expose capabilities. Its common contracts cover asset import, discovery decisions, result verification through write-then-read-back behavior, declarative recipes, and marketplace metadata such as example prompts, recovery guidance, and undo steps.

## How it works

DCC-MCP Core MCP server uses a gateway model. Agents can discover backend capabilities with search, inspect them with describe, load a skill when needed, and invoke operations through call. The gateway keeps the initial tool list bounded rather than publishing every backend tool at once. A REST counterpart is also documented for search, describe, and call operations.

For a concrete running session, the gateway exposes `gateway://instances`; entries include the MCP URL for each available host. The project also supports direct per-DCC MCP connections with compatibility discovery names where those servers provide them. Actions are dispatched to the DCC main thread, which addresses applications that are unsafe to script from a background thread. Structured results and postconditions are used so operations can report typed output and verify their effects.

Skills are packaged with `SKILL.md` and `tools.yaml`, with progressive discovery, validation, and hot reload. A single gateway can route requests across multiple live DCC sessions. When an application lacks a suitable API, the UI Control layer provides bounded screenshot-and-click automation as a fallback.

## Tools and capabilities

The listed MCP tools focus on scoped UI and computer-use control:

- `ui_control__snapshot` captures a bounded PNG and accessibility tree from the selected application.
- `ui_control__find` searches for semantic controls using a query, role, label, or object name.
- `ui_control__act` performs one scoped semantic or coordinate-based action.
- `ui_control__recording_start` starts CUA trajectory or video recording in an absolute output directory.
- `ui_control__recording_state` reports the current recording state.
- `ui_control__recording_stop` finalizes a recording for later rendering.
- `ui_control__wait_for` polls until a UI condition becomes true or the timeout expires.
- `ui_control__stop_computer_use` releases the capsule, hotkey, and global input owner.

The wider core also supplies gateway discovery and dispatch wrappers, REST access, shared asset-import behavior, recipe execution, diagnostics, IPC, workflows, and packaged CLI/server binaries according to the repository description.

## Setup and configuration

The repository points users to different entry points based on their goal. To control a running DCC from an agent or CI job, it directs users to install the DCC-MCP Agent Skill and use `dcc-mcp-cli`. To expose an adapter over MCP or REST, it documents `create_skill_server`; it also documents `dcc-mcp-core serve` for starting a server from a resolved Rez package.

Users adding capabilities without Python registration code can use `SKILL.md` with `tools.yaml`. The repository also provides guides for gateway routing, skill packages, new adapter development, and HTTP-client integration. Exact installation commands and host-specific requirements are not provided in the supplied material.

## Limitations and notes

DCC-MCP Core MCP server depends on the available host adapters and their registered capabilities. The repository lists 47 adapter entries in its catalog, but that catalog is the source of host coverage rather than a guarantee that every host is installed or active in a given environment.

The gateway’s preferred flow is discovery through search, inspection through describe, optional skill loading, and invocation through call. The README explicitly says not to use removed legacy instance tools such as `list_dcc_instances`, `get_dcc_instance`, or `connect_to_dcc`. Wrapper inputs belong inside the `arguments` field rather than beside `tool_slug`.

The UI Control tools are a fallback for applications without an API and use bounded, scoped interaction. Recording requires an absolute output directory. The supplied material does not define operating-system support, authentication behavior, or client-specific setup requirements.

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