maya-mcp-server
Integrates with Autodesk's Maya 3D modeling software for multi-session control and automation via Python.
Manages multiple Autodesk Maya sessions, enabling Python code execution, module creation, and output streaming.
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., "@maya-mcp-server create a poly sphere at the origin"
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.
maya-mcp-server
MCP server for interacting with Autodesk Maya sessions.
Features
Multi-session support: Manage multiple Maya sessions from a single MCP server. The server scans for new Maya sessions that have been started and shutdown by the user.
Full Python expressiveness: Execute arbitrary Python code. Agents can create virtual python modules to expose functions for execution, including by the user.
Streaming output: Capture stdout/stderr from Maya sessions via MCP resources. Agents can monitor output from their code or user activity.
Simple Maya-side setup: No modules to install in Maya: leverages Maya's command port to bootstrap itself.
Easy installation: Install and run via
uvx maya-mcp-server

Related MCP server: maya_mcp
Installation
# Using uvx (recommended)
uvx maya-mcp-server
# Or install with pip
pip install maya-mcp-serverUsage
Claude Code Configuration
Add to your Claude Code MCP configuration, run:
claude mcp add --transport stdio maya -- uvx maya-mcp-serverThe default scope is "local", which adds it to your ~/.claude.json keyed to a particular project directory. Setting --scope=user adds to ~/.claude.json across all projects, and --scope=project to add the configuration into a .mcp.json in the current project directory, so that it can be commited to your repo.
For local development use:
claude mcp add --transport stdio maya -- uv run --directory /path/to/maya-mcp-server/ maya-mcp-serverMaya Setup
The server automatically discovers Maya sessions via command ports. To enable a Python command port in Maya:
import maya.cmds as cmds
cmds.commandPort(name=":7002", sourceType="python")Or add to your userSetup.py for automatic startup.
Tools
Tools accept an optional session_key parameter for targeting specific sessions.
If only one Maya session exists, it will be auto-selected.
Session keys are returned by list_sessions and add_session.
Tool | Description |
| List all active Maya sessions. Returns session info including |
| Manually add a Maya session at a specific host:port. Use when auto-discovery doesn't find your session. |
| Create a virtual Python module in Maya. Useful for defining reusable functions. |
| Execute Python code in a session. Supports result capture modes: |
Resources
Resource | Description |
| Session information (pid, user, maya_version, scene_name, scene_path) |
| Captured stdout/stderr output from the session |
Similar tools
MayaMCP
This looks to be the first publicly available MCP server for Maya and I was inspired by a few aspects of this tool, especially the goal of zero Maya-side setup.
Disadvantages:
The MCP server is bound to a single Maya session running on the default port.
It is limited to a bespoke set of tools. This could be seen as a security advantage, but it cripples the ability of an agent to do just about anything.
No support for reading stdout or stderr, so the agent is blind to what's happening in the Maya session.
Less robust approach to capturing command output (e.g. does not check if code is indented within a
forloop or function)Can't run via
uvx, orpip installfrom pypi.
ChatGPT4Maya
This is the original LLM integration for Maya, which embeds ChatGPT directly in a PySide window and enables the LLM to respond to user commands and queries by executing code in the session.
Disadvantages:
Not an MCP server, so it cannot take full advantage of agentic workflows.
Only works with ChatGPT.
Jupyter MCP Server
This provided an interesting reference for how to create an MCP server in python that works with multiple remote sessions (in this case, notebooks) to execute arbitrary code.
Development
# Install dev dependencies
uv sync --dev
# Run tests
uv run pytest
# Run the server
uv run maya-mcp-serverLicense
MIT
TODO
Provide an option to
executeto run in global or private context.Yield output as it's printed?
Add tools to simplify interaction with UI: shelves, hotkeys, menus
Plugins to extend session info, e.g. with custom pipeline info
Investigate RPC for extensibility, implementation of custom tools
Use a dispatch function for command port mode, to further harmonize. Create a shared type safe collection of tools that hold name and arguments.
Return stdout and stderr lines interleaved (and prefixed with
STDOUT:STDERR:) so that the agent can determine order?Cleanup command ports when complete. This won't be necessary if we default to the Qt command server.
Available Tools
4 toolsadd_sessionA
Manually add a Maya session at a specific host and port.
Use this when auto-discovery doesn't find your Maya session, or to connect to a Maya instance on a specific port.
Args: host: The session host (default: "127.0.0.1") port: The session port number (default: 7001)
Returns: Session information for the added session
Before using this, ensure Maya has a Python command port open. In Maya's Script Editor (Python), run: import maya.cmds as cmds cmds.commandPort(name=':7001', sourceType='python')
Inputs: host, port. Returns: pid, host, port, user, +4 more
execute_codeA
Execute Python code in a Maya session.
Args: code: Python code to execute. result_type: How to handle the result: - "NONE": Execute statements, don't capture result - "JSON": Evaluate expression, JSON encode result - "RAW": Evaluate expression, return string representation session_key: Session key (optional if only one session exists)
Returns: Captured result (None if result_type is NONE)
Note: stdout and stderr are delivered in real-time via MCP Resource subscriptions (maya://sessions/{session_key}/stdout and /stderr). Call get_output() to retrieve buffered output.
Example: # Execute statements execute_code("import maya.cmds as cmds; cmds.polyCube()")
# Get JSON result
execute_code("cmds.ls(type='mesh')", result_type="JSON")Inputs: code (required), result_type, session_key.
list_sessionsA
List all active Maya sessions.
Returns a list of session information including:
session_key: Session key used to interact with tools and resources
host: Session host address
port: Session port number
pid: Maya process ID
user: Logged-in user
maya_version: Maya version string
scene_name: Current scene filename
scene_path: Full path to current scene
Note: To detect new or removed sessions, clients should call this tool periodically (e.g., every 10-30 seconds) and compare results. The SessionManager automatically scans for new Maya sessions in the background.
Inputs: no named parameters. Returns: result
write_moduleA
Create a virtual Python module in a Maya session.
Args: name: Module name. Can be a dotted path (e.g., 'mypackage.utils') in which case parent packages are created automatically. code: Python source code for the module. overwrite: If True, replace existing module. If False, raise error if module already exists. session_key: Session key (optional if only one session exists)
Returns: Success message
Example: write_module("mytools", ''' import maya.cmds as cmds
def create_cube(name="cube1"):
return cmds.polyCube(name=name)[0]
''')
# Then use it:
execute_code("import mytools; mytools.create_cube('myCube')")Inputs: code (required), name (required), overwrite, session_key. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool has a distinct purpose: listing sessions, writing modules, executing code, and adding sessions. No overlap, descriptions are clear.
All tool names follow a consistent verb_noun pattern using snake_case: list_sessions, write_module, execute_code, add_session.
Four tools cover the essential functions for a Maya remote control server: session listing, code execution, module creation, and manual session addition. Not too few nor too many.
The tool set provides core functionality for executing Python code and managing modules in Maya sessions. Minor gaps include dedicated output retrieval or scene manipulation tools, but the set is functional for its scope.
Maintenance
Related MCP Connectors
The official MCP Server for the Mux API
MCP Server for Slima - AI Writing IDE for Novel Authors with AI Beta Reader.
MCP server for mandates, delegation, policy-gated execution, credential grants, and audit.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceModel Context Protocol (MCP) server implementation for Autodesk Maya120MIT
- AlicenseNot gradedqualityNot gradedmaintenanceA Model Context Protocol server that enables AI assistants to interact with active Autodesk Maya sessions using the maya.cmds API. It allows users to manage scene objects, control selections, and perform common 3D operations through natural language.Apache 2.0
- AlicenseBqualityCmaintenanceA local Model Context Protocol server for controlling Autodesk Maya, providing typed tools for scene, modeling, animation, and more without Maya imports in the server process.71291 PyPI35MIT
- AlicenseAqualityDmaintenanceMCP server for orchestrating multiple Claude Code instances via tmux, enabling spawning, reading, sending, listing, and killing sessions.570 npm2MIT