Cinema4D MCP
Provides tools for interacting with Cinema 4D scenes, enabling AI agents to create and modify objects, manage cameras and animation, adjust lighting and materials, save/load scenes, and execute custom Python code inside Cinema 4D.
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., "@Cinema4D MCP Create a red sphere in the scene and animate it bouncing on the floor."
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.
Cinema4D MCP — Model Context Protocol (MCP) Server
Cinema4D MCP Server connects Cinema 4D to ChatGPT, Codex, Claude, and other MCP clients for prompt-assisted 3D manipulation.
Table of Contents
Usage Guide — practical tips, extraction patterns, and known issues
Related MCP server: BlenderMCP
Components
C4D Plugin: A socket server that listens for commands from the MCP server and executes them in the Cinema 4D environment.
MCP Server: A Python server that implements the MCP protocol and provides tools for Cinema 4D integration.
Prerequisites
Cinema 4D (R2024+ recommended)
Python 3.10 or higher (for the MCP Server component)
Installation
To install the project, follow these steps:
Clone the Repository
git clone https://github.com/ttiimmaacc/cinema4d-mcp.git
cd cinema4d-mcpInstall the MCP Server Package
pip install -e .Choose a Transport
The default stdio transport is suitable for local MCP clients:
cinema4d-mcp --transport stdioFor ChatGPT development and MCP Inspector, start the Streamable HTTP endpoint:
cinema4d-mcp --transport streamable-http --host 127.0.0.1 --port 8790 --path /mcpThe equivalent package command works on Windows without relying on a shell wrapper:
python -m cinema4d_mcp --transport streamable-httpOn Windows, double-click Start Cinema 4D Agent.cmd to start Cinema 4D, wait for
the plugin socket on port 5555, start the MCP endpoint on port 8790, and then
start the OpenAI Tunnel on port 8787. The launcher avoids duplicate processes
and writes runtime logs under %LOCALAPPDATA%\Cinema 4D Agent\runtime.
The PowerShell launcher also supports status, stop, and restart operations:
.\bin\start-cinema4d-agent.ps1 -Action Status
.\bin\start-cinema4d-agent.ps1 -Action Stop
.\bin\start-cinema4d-agent.ps1 -Action RestartSetup
Cinema 4D Plugin Setup
To set up the Cinema 4D plugin, follow these steps:
Copy the Plugin Folder: Copy the
c4d_plugin/Cinema 4D Agentfolder to Cinema 4D's plugin folder. The path varies depending on your operating system:macOS:
/Users/USERNAME/Library/Preferences/Maxon/Maxon Cinema 4D/plugins/Windows (Cinema 4D 2026):
C:\Program Files\Maxon Cinema 4D 2026\plugins\
Start the Socket Server:
Open Cinema 4D. The socket server starts automatically in the background without opening the Cinema 4D Agent dialog.
The server listens on
127.0.0.1:5555by default and stops when Cinema 4D exits.Open Extensions > Cinema 4D Agent only when you want to view logs or use Stop Server and Start Server. Closing the dialog does not stop the server.
Clear Start/stop Server with Cinema 4D to disable automatic startup on future Cinema 4D launches. The preference is saved between sessions; the two buttons continue to control the current session.
Claude Desktop Configuration
To configure Claude Desktop, you need to modify its configuration file:
Open the Configuration File:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonAlternatively, use the Settings menu in Claude Desktop (Settings > Developer > Edit Config).
Add MCP Server Configuration: For development/unpublished server, add the following configuration:
"mcpServers": { "cinema4d": { "command": "python3", "args": ["/Users/username/cinema4d-mcp/main.py"] } }Restart Claude Desktop after updating the configuration file.
ChatGPT Developer Setup
ChatGPT cannot connect directly to the Cinema 4D socket on port 5555. Keep that socket private and connect ChatGPT to the standard MCP endpoint instead:
Start Cinema 4D and confirm the Cinema 4D Agent socket is running.
Start
cinema4d-mcpwith thestreamable-httpcommand above.Verify
http://127.0.0.1:8790/mcpwith MCP Inspector.Enable Developer mode in ChatGPT under Settings > Security and login.
Create a Secure MCP Tunnel to the local MCP endpoint, then add that tunnel from ChatGPT Plugins.
Do not expose port 5555 to the internet. It is the private bridge between the Python MCP server and the Cinema 4D plugin, not an MCP transport.
HTTP settings can also be supplied through C4D_MCP_TRANSPORT, C4D_MCP_HTTP_HOST, C4D_MCP_HTTP_PORT, and C4D_MCP_HTTP_PATH.
Usage
Ensure the Cinema 4D Socket Server is running.
Start the MCP server using either
stdioorstreamable-http.Connect your MCP client and use the available Tool Commands.
Agent Skill
If you use agent skills, the maintained companion skill for this MCP lives in vladmdgolam/agent-skills.
The skill captures production-oriented guidance that sits on top of the raw MCP tools, including:
when to prefer
inspect_redshift_materialsover ad-hoc Python for Redshift inspectionwhen to fall back to
execute_python_scriptfor full C4D API accesscurrent Redshift limits when the runtime or node space is unavailable
practical MoGraph extraction and debugging workflows
Testing
Automated Regression Tests
After installing the package, run from the repository root:
python -m unittest discover -s tests -vThe suite covers MCP argument forwarding, nonblocking socket communication and HTTP discovery during pending tool calls, cancellation cleanup, main-thread plugin dispatch, scene loading, empty Capsule targets, inspection truncation, and rolling log refresh. Plugin unit tests use SDK doubles and require no C4D installation.
For native SDK validation, run tests/c4d_smoke.py on Cinema 4D's main thread
using runpy.run_path(<absolute script path>, run_name="__main__"). It loads the
candidate handler classes without registering another plugin, creates temporary
documents, checks save/load and graph operations, restores the previous active
document, and writes output/review-validation/c4d-smoke.json.
After updating the plugin source, close Cinema 4D and install it again. The
Windows installer targets Program Files and must be run from an administrator
PowerShell session:
.\bin\install-c4d-plugin.ps1Restart Cinema 4D and the MCP process to load the updated code. Running the smoke test does not replace the installed plugin.
Command Line Testing
To test the Cinema 4D socket server directly from the command line:
python main.pyYou should see output confirming the server's successful start and connection to Cinema 4D.
Testing with MCP Test Harness
The repository includes a simple test harness for running predefined command sequences:
Test Command File (
tests/mcp_test_harness.jsonl): Contains a sequence of commands in JSONL format that can be executed in order. Each line represents a single MCP command with its parameters.GUI Test Runner (
tests/mcp_test_harness_gui.py): A simple Tkinter GUI for running the test commands:python tests/mcp_test_harness_gui.pyThe GUI allows you to:
Select a JSONL test file
Run the commands in sequence
View the responses from Cinema 4D
This test harness is particularly useful for:
Rapidly testing new commands
Verifying plugin functionality after updates
Recreating complex scenes for debugging
Testing compatibility across different Cinema 4D versions
Troubleshooting & Debugging
Check the log files:
tail -f ~/Library/Logs/Claude/mcp*.logVerify Cinema 4D shows connections in its console after you open Claude Desktop.
Check the command-line options:
cinema4d-mcp --helpIf there are errors finding the mcp module, install it system-wide:
pip install mcpFor advanced debugging, use the MCP Inspector:
npx @modelcontextprotocol/inspector uv --directory /Users/username/cinema4d-mcp run cinema4d-mcp
Project File Structure
cinema4d-mcp/
├── .gitignore
├── LICENSE
├── README.md
├── main.py
├── pyproject.toml
├── setup.py
├── c4d_plugin/
│ └── Cinema 4D Agent/
│ └── mcp_server_plugin.pyp
├── src/
│ └── cinema4d_mcp/
│ ├── __init__.py
│ ├── server.py
│ ├── config.py
│ └── utils.py
└── tests/
├── test_server.py
├── mcp_test_harness.jsonl
└── mcp_test_harness_gui.pyTool Commands
General Scene & Execution
get_scene_info: Get summary info about the active Cinema 4D scene. ✅list_objects: List all scene objects (with hierarchy). ✅group_objects: Group selected objects under a new null. ✅execute_python: Execute custom Python code inside Cinema 4D. ✅save_scene: Save the current Cinema 4D project to disk. ✅load_scene: Load a.c4dfile into the scene. ✅set_keyframe: Set a keyframe on an objects property (position, rotation, etc.). ✅
Object Creation & Modification
add_primitive: Add a primitive (cube, sphere, cone, etc.) to the scene. ✅modify_object: Modify transform or attributes of an existing object. ✅create_abstract_shape: Create an organic, non-standard abstract form. ✅
Cameras & Animation
create_camera: Add a new camera to the scene. ✅animate_camera: Animate a camera along a path (linear or spline-based). ✅
Lighting & Materials
create_light: Add a light (omni, spot, etc.) to the scene. ✅create_material: Create a standard Cinema 4D material. ✅apply_material: Apply a material to a target object. ✅apply_shader: Generate and apply a stylized or procedural shader. ✅
Redshift Support
inspect_redshift_materials: Read-only Redshift inspector with fallbacks for assignments, preview colors, readable params, a renderEngine-style node-material probe, and a Redshift GraphView fallback viaredshift.GetRSMaterialNodeMaster(...). ✅ Known quirk: the top-levelcapabilities.redshift_module_availableflag can still befalseon some builds even when the per-material GraphView fallback succeeds. Treat each material'sgraph.backendandgraph.graphview.redshift_module_importedas the authoritative signal.validate_redshift_materials: Check Redshift material setup and connections. ✅ ⚠️ (Redshift materials not fully implemented)
Scene Nodes (Cinema 4D 2026.3.1)
inspect_scene_nodes_graph: Read the document Scene Nodes graph, including stable node/port paths, values, and connections. ✅search_scene_node_assets: Search installed Scene Nodes templates and return stable asset IDs. ✅describe_scene_node_asset: Inspect an installed template's ports and defaults without modifying the active document. ✅edit_scene_nodes_graph: Run ordered add, value, connection, disconnection, and removal operations with per-operation rollback. ✅layout_scene_nodes_graph: Apply Cinema 4D's native layout to a component, the current selection, or explicitly the whole graph. ✅
Typical workflow:
Search for an asset and describe it to obtain stable asset and port IDs.
Inspect the existing graph and retain the returned absolute node paths.
Submit one ordered edit batch. Each operation must have a unique
op_id; successful independent operations remain committed when another operation fails.Leave the default
layout="component"enabled to arrange the affected connected component once after the batch. Uselayout="none"to preserve manual placement.
{
"operations": [
{"op_id": "new_node", "type": "add_node", "asset_id": "<asset_id_from_search>"},
{
"op_id": "set_value",
"type": "set_port_value",
"node": {"op_id": "new_node"},
"port": "inputs/<port_id>",
"value": 1.0
}
],
"layout": "component",
"layout_after_batch": true
}See the Scene Nodes usage guide for complete examples, partial-success semantics, layout scopes, and harness setup.
Capsule Graphs (Cinema 4D 2026.3.1)
inspect_capsule_instances: Discover independent Nimbus graphs on scene objects and tags, then recursively expose nested Capsule node systems as separate stablegraph_targetvalues. ✅inspect_capsule_graph: Inspect nodes, ports, values, and connections in one exact target graph. ✅focus_capsule_graph: Select the target owner and ask the native Node Editor to show its graph. ✅ ⚠️search_capsule_assets: Search installed Capsule and NodeTemplate assets without modifying the Asset Repository. ✅describe_capsule_asset: Inspect public ports and editability in an isolated temporary document. ✅edit_capsule_graph: Edit only the specified editable instance graph with ordered, partial-success operations. ✅layout_capsule_graph: Request native layout for a component, selection, or explicitly the whole target graph. ⚠️
Always obtain graph_target from inspect_capsule_instances and preserve the complete object. It binds edits to a Nimbus owner UUID, owner type, NodeSpace, and absolute Capsule node path; asset ID and version are also checked whenever Cinema 4D still exposes them. The graph currently visible in the Node Editor never determines where a node is written. Nimbus UUIDs work for both objects and tags and remain stable when an owner is renamed; do not reconstruct targets from display names.
Nested Capsules on the same owner share the Nimbus owner UUID and NodeSpace but have different absolute capsule_node_path values. Their inspection and edits use a scoped graph view rooted at that path, so add_node creates inside the nested Capsule instead of at the owner graph root.
Cinema 4D can clear a nested instance's direct AssetId after its internal graph is first materialized. Discovery then returns an empty asset ID with asset_identity_status: "unavailable_after_materialization"; routing remains exact through the owner UUID, NodeSpace, and absolute NodePath, but asset-version change detection is unavailable for that target.
edit_capsule_graph fixes write_mode to instance_only; shared Capsule assets remain read-only. It tries to focus the editor first by default and keeps the target owner selected. Cinema 4D 2026.3.1 cannot expose the active Node Editor graph through Python, so a successful native focus request reports focus_status: "best_effort", editor_opened: null, node_space_matches: null, and graph_verified: false. Backend editing still uses the independently resolved target graph.
Cinema 4D 2026.3.1 does not expose a working Python invocation for native Node Editor layout in all contexts. In that case layout returns layout_status: "unavailable"; it does not guess node sizes or apply fixed coordinates.
See the Capsule Graphs usage guide for target examples and safety boundaries.
MoGraph & Fields
create_mograph_cloner: Add a MoGraph Cloner (linear, radial, grid, etc.). ✅add_effector: Add a MoGraph Effector (Random, Plain, etc.). ✅apply_mograph_fields: Add and link a MoGraph Field to objects. ✅
Dynamics & Physics
create_soft_body: Add a Soft Body tag to an object. ✅apply_dynamics: Apply Rigid or Soft Body physics. ✅
Rendering & Preview
render_frame: Render a frame and save it to disk (file-based output only). ⚠️ (Works, but fails on large resolutions due to MemoryError: Bitmap Init failed. This is a resource limitation.)render_preview: Render a quick preview and return base64 image (for AI). ✅snapshot_scene: Capture a snapshot of the scene (objects + preview image). ✅
Compatibility Plan & Roadmap
Cinema 4D Version | Python Version | Compatibility Status | Notes |
R21 / S22 | Python 2.7 | ❌ Not supported | Legacy API and Python version too old |
R23 | Python 3.7 | 🔍 Not planned | Not currently tested |
S24 / R25 / S26 | Python 3.9 | ⚠️ Possible (TBD) | Requires testing and fallbacks for missing APIs |
2023.0 / 2023.1 | Python 3.9 | 🧪 In progress | Targeting fallback support for core functionality |
2023.2 | Python 3.10 | 🧪 In progress | Aligns with planned testing base |
2024.0 | Python 3.11 | ✅ Supported | Verified |
2025.0+ | Python 3.11 | ✅ Fully Supported | Primary development target |
Compatibility Goals
Short Term: Ensure compatibility with C4D 2023.1+ (Python 3.9 and 3.10)
Mid Term: Add conditional handling for missing MoGraph and Field APIs
Long Term: Consider optional legacy plugin module for R23–S26 support if demand arises
Recent Fixes
Context Awareness: Implemented robust object tracking using GUIDs. Commands creating objects return context (guid, actual_name, etc.). Subsequent commands correctly use GUIDs passed by the test harness/server to find objects reliably.
Object Finding: Reworked find_object_by_name to correctly handle GUIDs (numeric string format), fixed recursion errors, and improved reliability when doc.SearchObject fails.
GUID Detection: Command handlers (apply_material, create_mograph_cloner, add_effector, apply_mograph_fields, set_keyframe, group_objects) now correctly detect if identifiers passed in various parameters (object_name, target, target_name, list items) are GUIDs and search accordingly.
create_mograph_cloner: Fixed AttributeError for missing MoGraph parameters (like MG_LINEAR_PERSTEP) by using getattr fallbacks. Fixed logic bug where the found object wasn't correctly passed for cloning.
Rendering: Fixed TypeError in render_frame related to doc.ExecutePasses. snapshot_scene now correctly uses the working base64 render logic. Large render_frame still faces memory limits.
Registration: Fixed AttributeError for c4d.NilGuid.
Available Tools
37 toolsadd_effectorB
Add a MoGraph Effector to the scene.
Args:
effector_type: Type of effector (random, shader, field)
name: Optional name for the effector
target: Optional target object (e.g., cloner) to apply the effector to
Inputs: effector_type (required), name, target. Returns: result
add_primitiveB
Add a primitive object to the Cinema 4D scene.
Args:
primitive_type: Type of primitive (cube, sphere, cone, cylinder, plane, etc.)
name: Optional name for the new object
position: Optional [x, y, z] position
size: Optional [x, y, z] size or dimensions
Inputs: primitive_type (required), name, size, position. Returns: result
animate_cameraB
Create a camera animation.
Args:
animation_type: Type of animation (wiggle, orbit, spline, linear)
camera_name: Optional name of camera to animate
positions: Optional list of [x,y,z] camera positions for keyframes
frames: Optional list of frame numbers for keyframes
Inputs: animation_type (required), frames, positions, camera_name. Returns: result
apply_dynamicsC
Add dynamics (rigid or soft) to the specified object.
Args:
object_name: Name of the object to apply dynamics to
dynamics_type: Type of dynamics to apply (rigid, soft)
Inputs: object_name (required), dynamics_type (required). Returns: result
apply_materialB
Apply a material to an object.
Args:
material_name: Name of the material to apply
object_name: Name of the object to apply the material to
Inputs: object_name (required), material_name (required). Returns: result
apply_mograph_fieldsB
Create and apply a MoGraph Field.
Args:
field_type: Type of field (spherical, box, cylindrical, linear, radial, noise)
target: Optional target object to apply the field to
field_name: Optional name for the field
parameters: Optional parameters for the field (strength, falloff)
Inputs: field_type (required), target, field_name, parameters. Returns: result
apply_shaderC
Create and apply a specialized shader material.
Args:
shader_type: Type of shader (noise, gradient, fresnel, etc)
material_name: Optional name of material to apply shader to
object_name: Optional name of object to apply the material to
Inputs: shader_type (required), object_name, material_name. Returns: result
create_abstract_shapeB
Create an organic, abstract shape.
Args:
shape_type: Type of shape (blob, metaball)
name: Optional name for the shape
Inputs: shape_type (required), name. Returns: result
create_cameraB
Create a new camera in the scene.
Args:
name: Optional name for the new camera.
position: Optional [x, y, z] position.
properties: Optional dictionary of camera properties (e.g., {"focal_length": 50}).
Inputs: name, position, properties. Returns: result
create_lightB
Add a light to the scene.
Args:
light_type: Type of light (area, dome, spot)
name: Optional name for the light
Inputs: light_type (required), name. Returns: result
create_materialC
Create a new material in Cinema 4D.
Args:
name: Name for the new material
color: Optional [R, G, B] color (values 0-1)
properties: Optional additional material properties
Inputs: name (required), color, properties. Returns: result
create_mograph_clonerC
Create a MoGraph Cloner object of specified type.
Args:
cloner_type: Type of cloner (grid, radial, linear)
name: Optional name for the cloner
Inputs: cloner_type (required), name. Returns: result
create_soft_bodyC
Add soft body dynamics to the specified object.
Args:
object_name: Name of the object to convert to a soft body
Inputs: object_name (required). Returns: result
describe_capsule_assetC
Describe a Capsule asset using an isolated temporary document.
Inputs: asset_id (required), asset_version. Returns: result
describe_scene_node_assetC
Describe a Scene Nodes asset in an isolated temporary document.
Inputs: asset_id (required). Returns: result
edit_capsule_graphB
Edit one exact Capsule instance graph with ordered partial-success operations.
Inputs: operations (required), graph_target (required), layout, debug_path, +3 more. Returns: result
edit_scene_nodes_graphC
Apply ordered Scene Nodes graph operations with per-operation rollback.
Inputs: operations (required), layout, debug_path, layout_after_batch. Returns: result
execute_python_scriptA
Execute a Python script in Cinema 4D's Python environment.
This is the most reliable tool for non-trivial operations — it gives full access
to the c4d API and avoids wrapper/schema mismatches that can affect other tools.
Args:
script: Python code to execute in Cinema 4D. Has access to `c4d` and
`c4d.modules.mograph` modules.
Important usage notes:
- For animated/MoGraph data, always call doc.ExecutePasses() after SetTime():
doc.SetTime(c4d.BaseTime(frame, fps))
doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_NONE)
- For MoGraph/effector data, iterate frames sequentially (0..N) rather than
jumping directly to a later frame — sequential stepping produces more
faithful results.
- Security restrictions block certain keywords: import os, subprocess, exec(, eval(.
Keep scripts within the c4d API surface.
- For heavy operations (dense frame loops, complex MoGraph scenes), split work
into multiple smaller scripts rather than one large monolith.
- Use print() to return results — output is captured and returned.
Inputs: script (required). Returns: result
focus_capsule_graphC
Select a Capsule owner and request that Cinema 4D show its exact graph.
Inputs: graph_target (required). Returns: result
get_scene_infoA
Get information about the current Cinema 4D scene.
Inputs: no named parameters. Returns: result
group_objectsC
Group multiple objects under a null object.
Args:
object_names: List of object names to group
group_name: Optional name for the group
Inputs: object_names (required), group_name. Returns: result
inspect_capsule_graphC
Inspect the exact Capsule instance graph identified by graph_target.
Inputs: graph_target (required), limit, max_bytes, max_ports, +7 more. Returns: result
inspect_capsule_instancesC
Discover object, tag, and Capsule instance graphs in the active document.
Inputs: limit, max_bytes, node_space, owner_guid, +1 more. Returns: result
inspect_redshift_materialsA
Inspect Redshift materials with best-effort fallbacks.
This tool is read-only and is designed to be useful even when the Redshift
Python runtime is unavailable. It can still report names, assignments,
preview-derived colors, readable description/container fields, and will
attempt graph inspection only when Cinema 4D exposes that data.
Args:
material_name: Optional material name filter
include_assignments: Include texture-tag assignments in the scene
include_preview: Include sampled preview bitmap color data
include_description: Include readable description entries
include_container: Include safe BaseContainer values
include_graph: Attempt node-graph inspection when available
Inputs: include_graph, material_name, include_preview, include_container, +2 more. Returns: result
inspect_scene_nodes_graphC
Inspect the document-level Cinema 4D Scene Nodes graph.
Inputs: limit, max_bytes, max_ports, node_path, +6 more. Returns: result
layout_capsule_graphC
Request native layout for one exact Capsule instance graph.
Inputs: graph_target (required), scope, node_path. Returns: result
layout_scene_nodes_graphD
Run Cinema 4D's native Scene Nodes layout command.
Inputs: scope, node_path. Returns: result
list_objectsA
List all objects in the current Cinema 4D scene.
If this tool returns a validation error, use execute_python_script as a fallback
to traverse the object hierarchy manually via the c4d API.
Inputs: no named parameters. Returns: result
load_sceneB
Load a Cinema 4D scene file.
Args:
file_path: Path to the scene file to load
Inputs: file_path (required). Returns: result
modify_objectC
Modify properties of an existing object.
Args:
object_name: Name of the object to modify
properties: Dictionary of properties to modify (position, rotation, scale, etc.)
Inputs: properties (required), object_name (required). Returns: result
render_frameB
Render the current frame.
Args:
output_path: Optional path to save the rendered image
width: Optional render width in pixels
height: Optional render height in pixels
Inputs: width, height, output_path. Returns: result
render_previewA
Render the current view and return a base64-encoded preview image.
Args:
width: Optional preview width in pixels
height: Optional preview height in pixels
frame: Optional frame number to render
Inputs: frame, width, height. Returns: result
save_sceneC
Save the current Cinema 4D scene.
Args:
file_path: Optional path to save the scene to
Inputs: file_path. Returns: result
search_capsule_assetsC
Search installed Capsule and NodeTemplate assets without modifying repositories.
Inputs: limit, query, category, node_space. Returns: result
search_scene_node_assetsB
Search installed Scene Nodes NodeTemplate assets.
Inputs: limit, query, category. Returns: result
set_keyframeC
Set a keyframe for an object property.
Args:
object_name: Name of the object
property_name: Name of the property to keyframe (e.g., 'position.x')
value: Value to set at the keyframe
frame: Frame number to set the keyframe at
Inputs: frame (required), value (required), object_name (required), property_name (required). Returns: result
snapshot_sceneB
Create a snapshot of the current scene state.
Args:
file_path: Optional path to save the snapshot
include_assets: Whether to include external assets in the snapshot
Inputs: file_path, include_assets. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 37 tools
Several tools occupy fuzzy boundaries: create_soft_body and apply_dynamics can both create soft bodies, render_frame and render_preview are easy to confuse, and add_effector / apply_mograph_fields / apply_shader overlap in material/effector workflows. The scene-nodes and capsule tool groups are structured but numerous, and get_scene_info, list_objects, and inspect_scene_nodes_graph all invite mis-selection for scene inspection.
All names are snake_case and mostly verb_noun, but the verb set is inconsistent: add_primitive, create_material, create_camera, add_effector, apply_dynamics, and create_soft_body capture similar actions with different verbs. The scene-nodes and capsule families are highly parallel, but their dense prefix/style can blur into one another.
37 tools is beyond a reasonably scoped MCP surface, especially when many are variants of inspect/edit/layout for Scene Nodes and Capsules. The core manipulation utilities could be much smaller; the additional sub-families push the set into heavier-than-useful territory.
The toolset is broad and covers scene creation, rendering, objects, materials, lights, animation, and MoGraph, but it has obvious lifecycle gaps like no direct object/material deletion and no dedicated keyframe-timeline management beyond set_keyfree. The execute_python_script fallback mitigates missing operations, but the structured API still has notable dead ends.
Related MCP Connectors
Build editable 3D scenes, direct characters and cameras, and export AI video references with MCP.
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
Direct AI video, image, music and storyboard production from any MCP client.
Generate game-ready 3D models, textures, and audio from natural language, over MCP.
Related MCP Servers
- AlicenseBqualityDmaintenanceConnects Cinema 4D to Claude, enabling AI-assisted 3D modeling and scene manipulation through natural language commands.25139MIT
- AlicenseBqualityDmaintenanceBlenderMCP enables Claude AI to directly interact with and control Blender for prompt-assisted 3D modeling, scene creation, and manipulation. It supports object and material control, scene inspection, and execution of Python code through natural language commands.17MIT
- AlicenseCqualityBmaintenanceEnables AI-powered control of Blender through natural language, allowing users to create, manipulate, and automate 3D scenes, objects, materials, animations, and more via Claude or other MCP clients.7165MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI-assisted 3D scene manipulation in Cinema 4D via natural language, using an MCP server that communicates with a C4D plugin.MIT