Overview

BlenderMCP is a lightweight MCP (Model Context Protocol) server that connects Claude AI to Blender for prompt-driven 3D modeling and scene manipulation. It exposes a set of remote tools that let Claude-style models read, generate, and edit Blender scenes programmatically. The server acts as a bridge: it receives MCP-style tool requests from an LLM, performs corresponding actions inside Blender (create meshes, position objects, change materials, render previews), and returns structured responses the model can use to continue an interactive session.

This approach is useful for interactive content creation, rapid prototyping, and automating repetitive scene tasks. Instead of writing Blender Python scripts manually, a developer can let a capable LLM interpret natural-language instructions and drive scene creation via the MCP server—enabling conversational 3D workflows, iterative refinement, and integration into multi-agent pipelines.

Repository: https://github.com/ahujasid/blender-mcp

Features

Exposes MCP-compatible tools that perform common Blender operations
Bi-directional integration: receive model-driven instructions and return structured scene state
Supports mesh creation, object transforms, material assignment, and renders/previews
Simple HTTP server for local or networked setups
Extensible toolset: add new operations by registering Python handlers
Logging and basic validation to aid debugging and model feedback loops

Installation / Configuration

Clone the repository and prepare a Python environment:

git clone https://github.com/ahujasid/blender-mcp.git
cd blender-mcp
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install -r requirements.txt

Set environment variables (example for a Claude API key if the server forwards requests or authenticates models):

export CLAUDE_API_KEY="sk-..."
export BLENDER_HOST="127.0.0.1"
export BLENDER_PORT="8080"

Start the MCP server:

python server.py --host 0.0.0.0 --port 3000

Start (or connect) Blender so that the server can apply scene changes. The repository includes a Blender-side script/add-on; install it in Blender or run the provided script to open a socket to the MCP server.

Available Tools / Resources

The server provides a set of tools (endpoint names and brief descriptions). These can be extended by modifying the handlers in the codebase.

Tool name	Purpose	Key parameters
create_mesh	Create a basic mesh (cube, sphere, plane)	type, name, size, location
edit_transform	Move/rotate/scale objects	object_name, translate, rotate, scale
set_material	Assign simple materials	object_name, color, roughness
list_objects	Return current scene object list	filter (optional)
render_preview	Render and return a preview image	resolution, camera_name

Example JSON request for create_mesh (sent as MCP tool call body):

{
  "tool": "create_mesh",
  "args": {
    "type": "cube",
    "name": "table_top",
    "size": [2.0, 1.0, 0.1],
    "location": [0, 0, 1.0]
  }
}

Example JSON request for edit_transform:

{
  "tool": "edit_transform",
  "args": {
    "object_name": "lamp",
    "translate": [0.5, -0.2, 0.3],
    "rotate": [0, 0, 1.57],
    "scale": [1, 1, 1]
  }
}

When a tool runs, the server returns structured output including status, any textual messages for the model, and data (like object lists or a base64-encoded preview image).

Use Cases

Prompt-driven scene prototyping: Ask Claude to “Create a minimalist living room with a couch, rug, and a floor lamp.” The model issues a sequence of create_mesh, set_material, and edit_transform calls to compose the scene. You can iterate with follow-up prompts like “Make the couch navy blue and raise the lamp by 20cm.”
Interactive modeling assistant: Use the MCP server in an editor UI where a designer issues high-level commands (voice or text). The server executes precise Blender operations, enabling faster mockups without manual Blender scripting.
Automated batch scene generation: Feed a dataset of scene descriptions to Claude and have the MCP server generate hundreds of variations programmatically for dataset creation or testing render pipelines.
Agent orchestration: Integrate into multi-agent systems where one agent designs geometry and another optimizes lighting/render settings—Claude uses the server tools to coordinate actions in a shared Blender environment.

Troubleshooting & Tips

Ensure Blender and the MCP server are reachable on the configured host/port. Network issues are a common cause of failures.
Start with small, deterministic tool calls (create a simple cube, list objects) when debugging model-driven workflows.
Logs are available in the server output—use them to inspect incoming tool requests and Blender API errors.
Extendability: add new tools by creating handlers in the server code and registering them in the tool registry; include spec metadata so models understand expected arguments.

This MCP server provides a practical bridge between Claude-style language models and Blender, enabling conversational and programmatic control of 3D scenes. For implementation details and contribution guidelines, see the project on GitHub: https://github.com/ahujasid/blender-mcp

BlenderMCP MCP Server for Claude AI 3D Modeling