Which integrations are available for this server?

Provides headless Blender asset QA and FBX reimport verification, enabling automated checks for mesh count, material count, and naming prefixes in CI pipelines.

How do I use ellmos Blender Use MCP?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ellmos Blender Use MCP verify FBX reimport for /models/prop.fbx" 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.

ellmos Blender Use MCP

by ellmos-ai

Overview Schema Related Servers Score Discussions

JavaScript

Local

ellmos Blender Use MCP

🇩🇪 Deutsche Version

Part of the ellmos-ai family.

npm version npm downloads Tests License: MIT Node.js Platform Privacy Security LLM-Ready Glama Ecosystem Umbrella

📦 View on npm → | 🛡️ Security Policy | 🤖 LLM Context | 🌐 Ecosystem

An asset-QA tool for game and 3D asset pipelines: verify that an exported FBX actually reimports cleanly in headless Blender — mesh count, material count, and required naming prefixes checked automatically, with a deterministic JSON result instead of a manual eyeball pass. blender_verify_fbx_reimport is the core tool; blender_locate and blender_run_script are the general-purpose primitives it is built on.

No add-on. No TCP port. No background daemon. This server does not install anything into Blender, does not open a socket for a running Blender instance to connect to, and does not keep Blender resident. Each call spawns blender --background --python <script.py>, waits for a bounded, timeout-guarded exit, and returns the result — headless and stateless by design. It does not download assets and does not collect telemetry.

How this differs from other Blender MCP servers. Most Blender MCP projects (e.g. ahujasid/blender-mcp, the official Blender Labs MCP server) drive a live, running Blender GUI over a TCP/add-on bridge for interactive scene editing — a different use case with a different trust model (an open socket, an installed add-on, a persistent process). This server instead targets CI-style, one-shot asset verification: run it in a pipeline step, get a pass/fail JSON, move on. If you need live GUI control, use a reviewed Blender MCP add-on separately (see Safety below).

NOTE

AI / LLM Integration & Machine-Readable Context: AI assistants (Claude, Codex, Gemini) can read llms.txt for machine-readable context, search phrases, and tool documentation. Regression test suites guard privacy hygiene and runtime memory safety.

TIP

CI & Asset Pipeline Automation: Use blender_verify_fbx_reimport as an automated gate before committing 3D assets to source control. It flags missing prefixes (e.g., SM_, M_), unexpected mesh counts, or broken material assignments without human intervention.

Architecture & Workflow

1. Component Topology

graph TD
    subgraph Client ["AI Assistant & Client Environment"]
        AI["AI Agent (Claude / Codex / Gemini)"]
        Config["MCP Configuration (npx / node)"]
    end

    subgraph Server ["ellmos Blender Use MCP Server"]
        MCP["MCP Protocol Server (src/index.js)"]
        subgraph Tools ["Tool Handlers"]
            T1["blender_verify_fbx_reimport"]
            T2["blender_run_script"]
            T3["blender_locate"]
        end
        Safety["Timeout & Tail Buffer Guard (8k chars)"]
    end

    subgraph Subprocess ["Headless Subprocess (Isolated)"]
        Exe["Blender Executable (blender --background)"]
        Python["Temp Python Verification Script"]
        FBX["Target FBX Asset File"]
        JSONOut["Deterministic JSON Result"]
    end

    AI -->|JSON-RPC Request| MCP
    MCP --> Tools
    T1 -->|Generates script & spawns| Exe
    T2 -->|Executes arbitrary python| Exe
    T3 -->|Locates binary| Exe
    Exe --> Python
    Python --> FBX
    FBX -->|Mesh / Material / Naming QA| JSONOut
    JSONOut --> Safety
    Safety -->|Bounded Response| AI

    style Client fill:#1e1e2e,stroke:#89b4fa,stroke-width:1px
    style Server fill:#181825,stroke:#cba6f7,stroke-width:1px
    style Subprocess fill:#11111b,stroke:#a6e3a1,stroke-width:1px

2. Headless Asset-QA Verification Lifecycle

sequenceDiagram
    autonumber
    actor Client as AI Assistant / CI Pipeline
    participant Server as ellmos Blender Use MCP
    participant Resolver as Blender Resolver
    participant Process as Headless Subprocess
    participant Python as Blender Python Engine
    participant FS as Local Filesystem (FBX)

    Client->>Server: Call blender_verify_fbx_reimport(fbxPath, requiredPrefixes)
    Server->>Resolver: Resolve Blender Executable (blender_locate / BLENDER_EXE / Registry / PATH)
    Resolver-->>Server: Return Validated Executable Path
    Server->>FS: Write Temp Python Verification Script
    Server->>Process: Spawn blender --background --python <script> (timeout-guarded)
    Process->>Python: Execute Verification Script
    Python->>FS: bpy.ops.import_scene.fbx(filepath=fbxPath)
    FS-->>Python: Parse Mesh Objects & Material Slots
    Python->>Python: Validate Naming Prefixes, Object Counts & Hierarchy
    Python->>FS: Write Output JSON Verification Result
    Process-->>Server: Process Exit (Exit Code 0 / Bounded Tail Buffer)
    Server->>FS: Read Result & Clean Up Temp Verification Script
    Server-->>Client: Deterministic JSON Result (meshCount, materialCount, missingPrefixes, ok)

Related MCP server: Blender MCP Server

Tools

Tool	Purpose
`blender_verify_fbx_reimport`	Generate a temporary Blender verification script, import an FBX, and write a JSON result with mesh/material counts and missing required prefixes.
`blender_run_script`	Run `blender --background --python <script.py>` with optional arguments and bounded stdout tail.
`blender_locate`	Resolve the Blender executable from an explicit path, `BLENDER_EXE`, the standard Windows install locations, or PATH.

Safety

This server runs local Python inside Blender. Use only scripts and asset paths you trust.
The default timeout is bounded.
No remote asset marketplaces, API keys, or telemetry are included.
For live GUI control, use a reviewed Blender MCP add-on separately.

Installation

Option 1: Run via npx (no install)

{
  "mcpServers": {
    "blender-use": {
      "command": "npx",
      "args": ["-y", "ellmos-blender-use-mcp"]
    }
  }
}

Option 2: Install from source

git clone https://github.com/ellmos-ai/ellmos-blender-use-mcp.git
cd ellmos-blender-use-mcp
npm install
npm run build
node src/index.js

For a local checkout, point command/args at the cloned src/index.js instead:

{
  "mcpServers": {
    "blender-use": {
      "command": "node",
      "args": ["<path-to-repo>/src/index.js"]
    }
  }
}

Configuration

BLENDER_EXE — optional path to the Blender executable. Without it, tools try the explicit blenderPath argument, then BLENDER_EXE, then the standard Blender install locations on Windows (%ProgramFiles%\Blender Foundation\Blender <version>\blender.exe and the equivalent 32-bit and per-user roots, newest version first), then PATH. On Linux and macOS the lookup goes straight from BLENDER_EXE to PATH.
Every tool also accepts an explicit blenderPath argument per call, which takes priority over BLENDER_EXE.
Process output is retained only as a tail: blender_run_script defaults to 8,000 characters (configurable up to 50,000); FBX verification keeps 8,000. The response marks outputTruncated: true when earlier output was discarded, so verbose Blender scripts cannot grow the MCP process memory without bound.

License

MIT — see LICENSE.

ellmos-ai Ecosystem

This MCP server is part of the ellmos-ai ecosystem — AI infrastructure, MCP servers, and intelligent tools.

MCP Server Family

Server	Tools	Focus	npm
FileCommander	46	Filesystem, process management, interactive sessions, cloud-lock-safe operations	`ellmos-filecommander-mcp`
CodeCommander	22	Code analysis, JSON repair, imports, diffs, regex	`ellmos-codecommander-mcp`
Clatcher	12	File repair, format conversion, batch operations	`ellmos-clatcher-mcp`
n8n Manager	18	n8n workflow management via AI assistants	`n8n-manager-mcp`
ControlCenter	20	MCP stack discovery, profile management, control plane	`ellmos-controlcenter-mcp`
Homebase	45	Local-first LLM memory, knowledge, state, routing, swarm orchestration	`ellmos-homebase-mcp` (alpha)
ServerCommander	8	Server operations: health checks, log analysis, deploy dry-runs, mail diagnostics	`ellmos-servercommander-mcp` (alpha)
Blender Use	3	Headless Blender asset QA and FBX reimport verification	`ellmos-blender-use-mcp` (alpha)
Open Compute	10	Model-agnostic computer use: capture, safety-gated actions, Windows UIA	`open-compute-mcp` (alpha)

AI Infrastructure & Developer Tools

Project	Description
workflowhooker	Transparent command interceptor & safety sandbox for agentic workflows
system-explorer	System inspection, MCP orchestration, and fleet introspection runtime
memoryhooker	High-performance episodic memory interceptor for AI agents
policy-registry	Policy distribution and compliance engine for multi-agent frameworks
ellmos-delegation-authority	Trust boundary verification & cryptographic token delegation authority
sqlite-transit-sync	Transactional SQLite transit replication with snapshot isolation
BACH	Local-first text-based OS for LLM agents — 113+ handlers, 550+ tools, SQLite memory
open-compute	Model-agnostic computer-use core powering Open Compute MCP
clutch	Provider-neutral LLM orchestration with auto-routing and budget tracking
rinnsal	Lightweight agent memory, connectors, and automation infrastructure
ellmos-stack	Self-hosted AI research stack (Ollama + n8n + Rinnsal + KnowledgeDigest)
MarbleRun	Autonomous agent chain framework for Claude Code
gardener	Minimalist database-driven LLM OS prototype (4 functions, 1 table)
ellmos-tests	Testing framework for LLM operating systems (7 dimensions)

Desktop Software Suite & Sibling Tools

Our partner organization open-bricks bundles AI-native desktop applications and developer utilities — a modern, open-source software suite built for the age of AI:

Project	Ecosystem	Description
ProFiler	`file-bricks`	Advanced file management, deep inspection, and batch pipeline workbench
DokuZen	`doc-bricks`	Unified document converter, markdown formatter, and documentation hub
PDFtoPDFocr	`doc-bricks`	High-fidelity OCR processor and searchable PDF pipeline
MediaBrain	`file-bricks`	AI-assisted media categorization, tagging, and asset management
TextBrain	`doc-bricks`	Text analysis, summarization, and local language intelligence suite
knowledgedigest	`open-bricks`	Knowledge extraction, semantic clustering, and synthesis engine
DevCenter	`dev-bricks`	Developer environment orchestration and multi-agent management cockpit
CodeBox	`dev-bricks`	Secure execution sandbox and isolated code-runner runtime

Available Tools

3 tools

blender_locateC

Resolve the local Blender executable used for background automation.

ParametersJSON Schema

Name	Required	Description	Default
`blenderPath`	No

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must fully disclose behavior. It states only that the tool 'resolves' an executable, but does not explain whether it searches system paths, how it handles the optional blenderPath parameter, what happens if Blender is not found, or what the return value looks like. This lack of detail leaves significant behavioral ambiguity.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, tightly worded sentence that immediately states the core purpose. It is appropriately sized and front-loaded with the key action ('Resolve'), with no wasted words or redundant detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has low complexity (one optional parameter, no output schema), making it feasible for the description to be complete. However, it omits crucial details: what the parameter does, what the tool returns, and error behavior. While the purpose is clear, the description is too skeletal for an agent to invoke the tool correctly in a real workflow.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema contains one parameter, blenderPath, with no description in the schema (schema coverage 0%). The tool description does not mention this parameter at all, so it fails to explain its purpose (e.g., whether it is an override or a hint). With low schema coverage, the description must compensate, and it does not.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool resolves the local Blender executable, using a specific verb ('Resolve') and resource ('local Blender executable'). It distinguishes itself from siblings like blender_run_script and blender_verify_fbx_reimport by focusing on locating the executable rather than executing or verifying.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no explicit guidance on when to use this tool or how it relates to the sibling tools. The phrase 'used for background automation' vaguely implies a setup/prerequisite step, but there is no mention of alternatives, exclusions, or typical workflow placement.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blender_run_scriptB

Run Blender in background mode with an explicit Python script and optional script arguments.

ParametersJSON Schema

Name	Required	Description	Default
`cwd`	No
`timeoutMs`	No
`scriptArgs`	No
`scriptPath`	Yes
`blenderPath`	No
`outputTailChars`	No

TDQS

B3.3/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'background mode' but does not disclose potential side effects, output handling, error behavior, timeout implications, or whether the script execution is blocking. This is insufficient for a tool that runs arbitrary scripts and could have significant side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that conveys the core functionality without any wasted words. It is appropriately concise for the tool's purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has 6 parameters, no annotations, and no output schema, the description is incomplete. It does not explain how output is returned, the meaning of timeoutMs, cwd, blenderPath, or outputTailChars, nor does it mention any constraints or side effects. The description provides only a surface-level understanding, which is inadequate for a tool with this complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It only mentions 'explicit Python script' and 'optional script arguments', which loosely map to scriptPath and scriptArgs, but it completely omits cwd, timeoutMs, blenderPath, and outputTailChars. The description adds minimal meaning beyond the parameter names and fails to explain the purpose of most parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool runs Blender in background mode with an explicit Python script and optional script arguments. It specifies the action (run), the resource (Blender), and the mode (background), which distinguishes it from sibling tools like blender_locate (locating Blender) and blender_verify_fbx_reimport (verifying FBX reimport).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies its usage by saying 'Run Blender in background mode with an explicit Python script', but it does not explicitly state when to use this tool versus alternatives or provide any exclusions. There is no mention of prerequisites or conditions for use, so it remains implied rather than explicitly guided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blender_verify_fbx_reimportC

Import an FBX in headless Blender and write/read a JSON verification result.

ParametersJSON Schema

Name	Required	Description	Default
`fbxPath`	Yes
`timeoutMs`	No
`resultPath`	No
`blenderPath`	No
`requiredPrefixes`	No

TDQS

C2.8/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of disclosing side effects and runtime behavior. It mentions headless Blender and file I/O, but omits external dependencies, error cases, and what the verification result contains.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no filler, front-loading the primary action and result. It is appropriately concise for the amount of information it conveys.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

This is a tool with five parameters, no output schema, and no annotations, yet the description is only a vague one-liner. It does not explain return values, parameter semantics, or the meaning of the verification result, making it insufficient for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not mention or explain any of the five parameters. Required fields like fbxPath and optional parameters like resultPath and requiredPrefixes are completely undocumented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Import') and a specific resource ('FBX in headless Blender'), and clearly indicates the JSON verification output. This distinguishes it from siblings like blender_locate and blender_run_script, which target different actions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus the sibling tools, nor does it mention any alternatives or exclusions. It simply states the action without placement in a workflow.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.3/5.0

Disambiguation4/5

Each tool has a distinct purpose: locating the executable, running a script, and verifying FBX re-import. The only slight overlap is that verify_fbx_reimport is a specialized form of run_script, but the descriptions clarify their intended uses.

Naming Consistency5/5

All tool names follow a consistent 'blender_<verb>...' pattern (locate, run_script, verify_fbx_reimport). The naming convention is uniform and predictable.

Tool Count5/5

With only 3 tools, the set is tightly scoped to Blender automation workflows. Each tool serves a clear and necessary function, and the count is well within the expected range for a focused utility server.

Completeness3/5

The toolset covers the core workflow of locating Blender, running scripts, and verifying FBX files, but lacks generic ways to retrieve script output or handle other common Blender operations. This leaves some gaps for broader automation scenarios.

Maintenance

ActivityActive

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Related MCP Connectors

ChiR24-unreal_mcpOAuth
ai.smithery
Control Unreal Engine to browse assets, import content, and manage levels and sequences. Automate…
Developer Tools App Automation Multimedia Processing
2847
validate A
io.github.machinegrade
Deterministic validation for AI-generated artifacts: JSON Schema, OpenAPI response, SQL syntax.
API Testing Testing & QA Tools
121
mcp-spec-compliance-mcp
io.github.CSOAI-ORG
MCP Spec Compliance MCP — audits any MCP server.json against the official Model Context Protocol
Testing & QA Tools Developer Tools
2
Venture Foundry QA A
io.github.ventureagent-ai
Preflight QA for AI-agent deliverables with structured verdicts and repair guidance.
Testing & QA Tools Autonomous Agents AI & Machine Learning
51

Related MCP Servers

Blender MCP Link
Design Tools Autonomous Agents
ENG-cpu-bit
A
license
Not graded
quality
C
maintenance
Enables interactive control of Blender for 3D scene manipulation, geometry creation, material application, and viewport rendering via natural language prompts through the Model Context Protocol.
Updated 3 months ago (2026-05-26 01:49 UTC)
MIT
Blender MCP Server
Design Tools Developer Tools
namurokuro
A
license
Not graded
quality
D
maintenance
Exposes 50+ Blender tools (object manipulation, materials, animation, etc.) via MCP for AI-driven 3D workflows and automation.
Updated 7 months ago (2026-01-20 00:44 UTC)
1
MIT
blender-mcp
Design Tools Multimedia Processing
zorak1103
A
license
Not graded
quality
B
maintenance
Enables LLMs to control Blender for 3D scene creation, object manipulation, material assignment, shader configuration, modifier application, keyframing, and rendering via the Model Context Protocol.
Updated 2 days ago (2026-08-31 02:47 UTC)
2
GPL 3.0
Blender MCP Server
Design Tools Autonomous Agents
Mohammed-saad-riyan
F
license
Not graded
quality
B
maintenance
Enables AI agents to fully control Blender through 50+ tools for 3D modeling, animation, materials, and scene management via HTTP endpoints.
Updated 2 months ago (2026-07-07 21:35 UTC)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/ellmos-ai/ellmos-blender-use-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server