blender-mcp: A Socket-Based Bridge for Driving Blender from Any LLM

What Problem Does blender-mcp Solve?

Blender is a powerful but complex 3D modeling tool. Its interface has a steep learning curve, and many repetitive tasks, such as creating primitive objects, adjusting materials, or inspecting scene hierarchies, require navigating menus and panels. blender-mcp aims to replace that manual interaction with natural language prompts. It is a community plugin, not an official Blender feature, that lets you ask an LLM like Claude to build or modify a scene. The target user is someone who already uses an MCP-compatible client and wants to speed up their Blender workflow without learning every hotkey. The README positions it as a bridge: the LLM sends commands, the plugin executes them in Blender, and the results are sent back.

Architecture: Two Components, One Socket Connection

The system is split into two distinct pieces. The first is a Blender addon, `addon.py`, which creates a socket server inside Blender. That server listens for incoming commands and executes them. The second is a Python MCP server, `src/blender_mcp/server.py`, which implements the Model Context Protocol and connects to the Blender addon. The MCP server is what your LLM client talks to, using the standard MCP protocol. The addon and server communicate over a socket, which means the LLM client does not directly touch Blender. This separation is important because Blender runs its own Python interpreter, and the addon must live inside that environment. The README describes this as two-way communication: commands flow from the LLM to Blender, and scene information flows back. This design is typical for MCP integrations, but it introduces a moving part: if the socket connection drops, the LLM has no way to reach Blender.

Getting It Running: uv, a Client, and a Blender Addon

The quickstart requires three steps. First, install `uv`, the Python package manager. The README is emphatic: use the official installer, not `pip install uv`, because pip may not create the `uvx` command or may hide it inside an environment your MCP client cannot see. Second, point your MCP client at the server. For Claude Desktop, you edit its config JSON to add a server entry with `"command": "uvx"` and `"args": ["blender-mcp"]`. For Claude Code, the command is `claude mcp add blender uvx blender-mcp`. For Codex, it is `codex mcp add blender -- uvx blender-mcp`. Third, install the Blender addon by running `uvx blender-mcp install-addon`, then enable it in Blender under Edit → Preferences → Add-ons → Interface: MCP for Blender. Finally, in Blender's 3D viewport, press `N`, open the MCP tab, and click Start MCP Server. The README warns to run only one instance of the MCP server at a time, either in Cursor or Claude Desktop, not both. A notable gotcha is that GUI-launched clients do not inherit your terminal PATH, so a bare `uvx` may fail with `spawn uvx ENOENT`. The fix is to use the full path to `uvx`, found via `which uvx` or `where uvx`.

Capabilities: From Primitives to AI-Generated Models

The feature list covers object manipulation: create, modify, and delete 3D objects. Material control lets you apply and change materials and colors. Scene inspection gives the LLM detailed information about the current scene, which is necessary for it to make informed changes. The most powerful and risky feature is code execution: the LLM can run arbitrary Python code in Blender. That is not a sandbox; it is full access to Blender's Python API. Beyond basic operations, the plugin can pull assets from Poly Haven, models from Sketchfab, and low-poly models from Poly Pizza. It also supports AI-generated 3D models via Hyper3D Rodin and Hunyuan3D, though the README does not detail how those integrations authenticate or what they cost. For a user, this means the plugin is not just a command sender; it is a pipeline for bringing external assets into Blender.

Security and Failure Modes: What the README Warns About

The README includes a section on limitations and security considerations, though the cleaned text only hints at it. The obvious risk is arbitrary code execution. If your LLM client is compromised, or if you point it at a malicious prompt, it can run destructive Python in Blender. This is not a theoretical issue; it is inherent to the design. The README also mentions telemetry control, meaning the plugin may collect usage data, and you can disable it. On the failure side, the PATH issue is a common stumbling block: `spawn uvx ENOENT` appears even when `uvx` works in a terminal. Another failure mode is running multiple server instances, which the README explicitly warns against. If two clients connect, you will likely get conflicts or undefined behavior. The socket connection itself is also a point of failure; if Blender or the server crashes, the LLM will not know until it tries to send a command. The README does not describe any reconnection logic, so you may need to restart the server manually.

Alternatives: Comparing Approaches to AI-Assisted 3D

The main alternative is to use Blender's built-in Python scripting without an MCP layer. You can write scripts that manipulate the scene and run them from Blender's text editor or command line. That approach gives you full control and does not depend on an external LLM client. The difference is that scripting requires you to know Blender's Python API and to formulate commands yourself. blender-mcp moves that burden to the LLM, but it adds a dependency on an MCP client and a socket server. Another alternative is specialized AI plugins that generate models directly, such as the Hyper3D Rodin integration mentioned in the README. Those tools often have their own UI and do not require a general-purpose LLM. The trade-off is that they are narrower in scope. blender-mcp is general, but it inherits the LLM's unpredictability. A wrong prompt can produce a wrong object, and you need to inspect the result visually.

Maintenance and Upgrade Cost

The repository has no recent releases listed in the provided material, but the last push was September 2026, which suggests active development. The README includes an upgrading section for existing users, but the cleaned text does not specify the exact steps. Based on the setup, upgrades likely involve pulling the latest version from PyPI and reinstalling the addon. Because the plugin depends on `uv` and `uvx`, you need to keep those up to date as well. The license is MIT, which means you can modify and redistribute it freely, but there is no warranty. The project is a community effort, not affiliated with Blender, so support is limited to the Discord server and GitHub issues. The maintenance cost for a user is moderate: you must track changes to the MCP server and the addon, and ensure they stay compatible with your Blender version. The README does not specify a minimum Blender version beyond 3.0, so newer Blender releases may introduce breaking changes.

Editorial conclusion

Adopt blender-mcp if you are a Blender user who wants to experiment with prompt-driven modeling and already use an MCP-compatible client like Claude Desktop or Cursor. Skip it if you need a production-grade tool with formal support, or if you cannot accept the risk of arbitrary Python code execution in Blender. Before adopting, verify that your Blender version is 3.0 or newer, that uv is installed via the official installer, and that your MCP client can find uvx. Also review the telemetry control settings and understand that running the server exposes Blender to commands from your LLM client, so use it only in trusted environments.

Official sources

1. ahujasid/blender-mcp on GitHub
2. Issues
3. License: MIT
4. Project website
5. README