Skip to main content
Glama
maya-mcp-server

maya-mcp-server

by chadrik

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

screen_recording_4x.gif

Related MCP server: maya_mcp

Installation

# Using uvx (recommended)
uvx maya-mcp-server

# Or install with pip
pip install maya-mcp-server

Usage

Claude Code Configuration

Add to your Claude Code MCP configuration, run:

claude mcp add --transport stdio maya -- uvx maya-mcp-server

The 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-server

Maya 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_sessions

List all active Maya sessions. Returns session info including session_key for use with other tools/resources.

add_session

Manually add a Maya session at a specific host:port. Use when auto-discovery doesn't find your session.

write_module

Create a virtual Python module in Maya. Useful for defining reusable functions.

execute_code

Execute Python code in a session. Supports result capture modes: NONE, JSON, RAW.

Resources

Resource

Description

maya://sessions/{session_key}/info

Session information (pid, user, maya_version, scene_name, scene_path)

maya://sessions/{session_key}/output

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 for loop or function)

  • Can't run via uvx, or pip install from 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-server

License

MIT

TODO

  • Provide an option to execute to 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 tools
add_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

    A4.5/5.0

    Scored across 4 tools

    Disambiguation5/5

    Each tool has a distinct purpose: listing sessions, writing modules, executing code, and adding sessions. No overlap, descriptions are clear.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern using snake_case: list_sessions, write_module, execute_code, add_session.

    Tool Count5/5

    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.

    Completeness4/5

    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

    ActivityInactive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      A 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
    • A
      license
      B
      quality
      C
      maintenance
      A 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.
      71
      291 PyPI
      35
      MIT