Blender MCP

offiziell

Ein leichtgewichtiger MCP-Server (Model Context Protocol) für Blender. Er bietet eine natürliche Sprachschnittstelle zur Blender-Python-API, verbessert den Zugriff auf die Dokumentation und ermöglicht es Benutzern, komplexe Setups zu erkunden und zu verstehen.

Auf blender.org ansehen

Was kann man mit Blender MCP machen?

Szenenleistung analysieren — Bitten Sie den Assistenten, Objekte mit der höchsten Polygonanzahl im Verhältnis zu ihrer Bildschirmgröße aus der Kameraperspektive zu finden.
Datenblöcke umbenennen — Korrigieren Sie Tippfehler oder wenden Sie beschreibende Namenskonventionen für Objekte, Lichter, Kameras, Texturen und andere Datenblöcke an.
Datenbeziehungen abfragen — Verwenden Sie natürliche Sprache, um zu fragen, welche Objekte ein bestimmtes Material verwenden oder wie Datenblöcke verbunden sind.
Szenenprobleme debuggen — Identifizieren Sie Objekte mit der höchsten Polygonanzahl, nicht-manifolden Meshes oder anderen häufigen Problemen in der geöffneten Datei.
Geometry Nodes-Setups dokumentieren — Generieren Sie Inline-Dokumentationsrahmen und einen Textdatenblock, der erklärt, was eine Node-Gruppe tut und wie sie strukturiert ist.

Dokumentation

Ein leichtgewichtiger MCP (Model Context Protocol) Server für Blender. Er bietet eine natürlichsprachliche Schnittstelle zur Python-API von Blender, verbessert den Zugang zur Dokumentation und ermöglicht es Benutzern, komplexe Setups zu erkunden und zu verstehen.

Technische Details und Dokumentation zur Architektur finden Sie im Quellcode.

Sicherheitswarnung
Der MCP-Server führt von LLMs generierten Code in Blender ohne jegliche Schutzmaßnahmen aus, die Ihre Daten vor Löschung oder dem Versand an einen entfernten Ort schützen. Um Ihre Daten zu schützen, wird die Verwendung einer virtuellen Maschine oder eines Systems ohne Zugriff auf sensible Informationen empfohlen.

Installation

Blender verfügt über keine integrierte Funktionalität zur Verbindung mit LLMs.

Damit Blender eine Verbindung zu LLMs herstellen kann, müssen drei externe Tools manuell heruntergeladen, installiert und ausgeführt werden.

Voraussetzungen:

Blender 5.1 oder neuer
Add-on
LLM-Client
MCP-Server

Add-on

Um mit Ihrer Blender-Sitzung zu interagieren, müssen Sie ein spezielles Add-on für die MCP-Server-Integration installieren.

Per Drag & Drop in Blender einfügen

…oder herunterladen und von Datenträger installieren

Wenn Sie das Add-on per Drag & Drop in Blender einfügen, müssen Sie dies zweimal tun. Zuerst, um das Blender Lab-Repository hinzuzufügen, und dann, um das Add-on selbst zu installieren. Diese Methode ermöglicht es Ihnen, Update-Benachrichtigungen zu erhalten, sobald eine neue Version dieses Add-ons verfügbar ist.

LLM-Client

MCP-Server folgen einem klar definierten Standard und sind mit einer Vielzahl von Clients kompatibel. Bitte folgen Sie der Llama.cpp-Dokumentation oder installieren Sie einen LLM-Client Ihrer Wahl.

MCP-Server

Es gibt verschiedene Möglichkeiten, den MCP-Server zu installieren, abhängig von den Fähigkeiten Ihres LLM-Clients.

MCP-Bundle: Für neuere Clients, die .mcpb-Dateien unterstützen, laden Sie das neueste Paket von der Release-Seite herunter. Llama.cpp unterstützt dies noch nicht.
MCP-Server: Für die Installation aus dem Quellcode lesen Sie die Llama.cpp-Dokumentation oder die Setup-Anweisungen.

Ausführung

Sobald Sie Ihren MCP-Server in Ihrem LLM-Client eingerichtet haben, können Sie beginnen, Ihre Blender-Szenen zu erkunden.

Llama.cpp-Weboberfläche, auf der der Blender-MCP-Server läuft.

Beispiel 1: Szenenanalyse

MCP kann verwendet werden, um die Szene programmatisch auf Performance-Engpässe zu analysieren. Nehmen wir zum Beispiel die Classroom-Demodatei:

Classroom-Demodatei.

Diese Szene ist eine der Blender-Benchmark-Dateien. Der Grund, warum diese Dateien im Benchmark enthalten sind, liegt darin, dass sie eine gute Repräsentation echter, von Künstlern erstellter Produktionsdateien darstellen. Und es ist keine Überraschung, dass sie Objekte enthalten können, die optimiert werden können.

Während die Überprüfung der Polygonanzahl oft ausreicht, ist es noch interessanter, die Anzahl der Polygone basierend auf ihrer Größe im finalen Rendering darzustellen. Dies kann mit dem folgenden Prompt erreicht werden.

Analyze the scene and list the outliers: objects with highest polygon count but smaller size from the camera point of view.

Die dargestellten Ergebnisdaten zeigen deutlich zwei Objekte, die aus der Masse herausstechen: alphabet und coat 1:

Diagrammanalyse der Polygonanzahl pro Bildschirmfläche für die Classroom-Demoszene.

Das alphabet-Objekt hat 20.000 Polygone. Aufgrund seiner flachen Anordnung könnte es mit geringen Einbußen im Endergebnis durch eine Textur ersetzt werden. Das coat 1-Objekt hat aufgrund seines Subsurf-Modifikators 37.000 Polygone. Eine Verringerung des Unterteilungsgrads könnte die Szene entlasten, falls der Speicher der Engpass in Ihrem System ist.

Das Alphabet befindet sich im Hintergrund der Szene und könnte leicht durch eine Textur ersetzt werden. Der Mantel ist ebenfalls weit genug entfernt, sodass sein Mesh vereinfacht werden könnte.

Wie zuverlässig sind diese Ergebnisse?

Die erste vom LLM zurückgegebene Analyse berücksichtigte nur die Modifikatoren, die das Viewport beeinflussten. Das coat 1-Objekt hat einen Solidify-Modifikator, der seine Polygonanzahl verdoppelt, was es zu einem noch größeren Ausreißer macht. Und obwohl in dieser Szene kein Simplify aktiviert war, hätte diese Einstellung die endgültige Analyse ebenfalls beeinflusst.

Beispiel 2: Verschiedene Prompts

Dies sind einige der anderen getesteten Anwendungsfälle. Sie müssen den gesamten Inhalt des „Prompt“ einfügen, damit sie funktionieren. Als Ausgangspunkt sollten Sie die entsprechende Demodatei verwenden. Der Erfolg der Operation hängt vom verwendeten Modell ab.

Anwendungsfall	Prompt	Demodatei	Ergebnis
Datenblock-Umbenennung: Tippfehler beheben	Behebe mit der aktuell geöffneten Blender-Datei die Namen aller Datenblöcke, um Tippfehler zu entfernen. Melde zurück, welche Datenblöcke korrigiert wurden.	Scattering Pebbles	GRP-rocks → GRP-pebble, LGT-Lights → LGT-lights, Compositing Nodetree → Compositing Node Tree
Datenblock-Umbenennung: bessere Namen	Schlage mit der aktuell geöffneten Blender-Datei beschreibende Namen für alle Datenblöcke vor und wende sie nach Genehmigung an.	Scattering Pebbles	Camera → CAM-main, Area → LGT-sun-key, Area.001 → LGT-sun-fill, Area.002 → LGT-area-rim, GEO-pebble.001 → GEO-pebble-B, …
Abfragen von Datenbeziehungen in natürlicher Sprache	Welche Objekte verwenden das folgende Material: pebbles	Scattering Pebbles	7 Objekte: GEO-pebble, GEO-pebble.001, GEO-pebble.002, GEO-pebble.003, GEO-pebble.004, GEO-pebble.005, GEO-pebble.006
Szenen-Debugging	Welches Objekt in dieser Datei hat die höchste Polygonanzahl? Ignoriere Objekte, die mit keiner Szene verknüpft sind.	Scattering Pebbles	GEO-ground mit 4.096 Flächen.
Geometry Nodes-Dokumentation	Erkläre mit der aktuell geöffneten Blender-Datei, was das Haupt-Geometry-Nodes-Setup macht. Füge Inline-Dokumentation dafür mit Rahmen-Elementen hinzu. Erstelle einen Text-Datenblock mit dem Ergebnis der Analyse.	Scattering Pebbles	4 große farbcodierte Rahmen + Textdatei mit Erklärung.

Weitere Prompts, die noch untersucht werden müssen:

Übersetze alle Datenblöcke von Französisch nach Englisch.
Mein Mesh wird nicht von meiner Armature verformt, wie kann ich das beheben?
Blender hat nicht genug Arbeitsspeicher beim Rendern dieser Szene, wie kann ich sie optimieren?
Dieses Mesh hat seltsame Schattierungsartefakte, wie kann ich das beheben?
Finde Objekte mit Meshes, die schlechte Normalen haben.
Überprüfe meine Szene auf nicht-uniform skalierte Mesh-Objekte.
Das exportierte Video wird in meinen Webbrowsern nicht abgespielt, welche Einstellungen sollte ich ändern?
Welche Sculpt-Pinsel sollte ich zum Erstellen und Detaillieren von Ästen verwenden?
Richte Compositing-Nodes ein, um mein Bild sowohl als SDR als auch als HDR zu speichern.
Überprüfe diese Checkliste: Meshes müssen manifold sein, alle Objekte müssen Materialien haben, die Benennung muss der Konvention folgen, keine absoluten Pfade, … Datenblock-Umbenennung: Tippfehler beheben

GRP-rocks → GRP-pebbles (die Szene enthält nur Kieselobjekte, keine Steine).

LGT-Lights → LGT-lights (inkonsistente Groß-/Kleinschreibung).

Compositing Nodetree → Compositing Node Tree (Nodetree ist ein Kompositum-Fehler).

Datenblock-Umbenennung: bessere Namen

Objekte:

Camera → CAM-main
Area → LGT-sun-key
Area.001 → LGT-sun-fill
Area.002 → LGT-area-rim
GEO-pebble.001 → GEO-pebble-B
GEO-pebble.002 → GEO-pebble-C
GEO-pebble.003 → GEO-pebble-D
GEO-pebble.004 → GEO-pebble-E
GEO-pebble.005 → GEO-pebble-F
GEO-pebble.006 → GEO-pebble-G

Licht-Datenblöcke:

Area → LGT-sun-key
Area.001 → LGT-sun-fill
Area.002 → LGT-area-rim

Kamera-Datenblock:

Camera → CAM-main

Texturen:

Texture → TEX-ground-clouds
Texture.001 → TEX-ground-image

Szene & Welt:

World → WLD-environment
Scene → SCN-main Geometry Nodes-Dokumentation

Neue erstellte Rahmen:

Dokumentationsrahmen, die dem Geometry-Nodes-Setup hinzugefügt wurden.

Text-Datenblock:

GEOMETRY NODES ANALYSIS -- "Pebble Scattering Nodes"
Applied to object: GEO-ground   |   Modifier: Pebbles
========================================================

OVERVIEW
--------
This node group scatters three size categories of pebble meshes across
the faces of a ground mesh.  Each category uses its own density mask
and a global Factor multiplier so that coverage can be art-directed
per-layer without touching the raw mask textures.  The three resulting
instance layers are merged with the original ground geometry and sent
to the Group Output.

INPUTS (Group Interface)
------------------------
  Geometry           -- The ground mesh to scatter pebbles on.
  Large Pebbles Mask -- Float mask (e.g. vertex colour / texture) that
                       defines WHERE large pebbles may appear.
  Medium Pebbles Mask-- Float mask for medium pebble placement regions.
  Small Pebbles Mask -- Float mask for small pebble placement regions.
  Factor             -- Global density multiplier shared by all three
                       lanes (appears three times in the interface,
                       one per lane).

NODE GRAPH -- LANE BY LANE
--------------------------

+- LARGE PEBBLES LANE -----------------------------------------------------+
|  Source object : GEO-pebble                                              |
|  Group Input.001                                                         |
|    +- Geometry ------------------------> Distribute Points on Faces      |
|    +- Large Pebbles Mask ------------> Distribute Points on Faces        |
|    |                                     (Density Factor socket)         |
|    +- Factor --> Math.003 (x)  -------> Distribute Points on Faces       |
|                                          (Density Max socket)            |
|  Distribute Points on Faces ----------> Instance on Points               |
|  Object Info (GEO-pebble) -----------> Instance on Points (Instance)     |
|  Random Rotation.001 [-pi, +pi] -----> Instance on Points (Rotation)     |
|  Random Value [0.25 - 0.60]   -------> Instance on Points (Scale)        |
|  Instance on Points ------------------> Join Geometry.003                |
+--------------------------------------------------------------------------+

+- MEDIUM PEBBLES LANE ----------------------------------------------------+
|  Source object : GEO-pebble.004                                          |
|  Group Input.002                                                         |
|    +- Geometry ------------------------> Distribute Points on Faces.001  |
|    +- Medium Pebbles Mask -----------> Math.004 (x) --> Math.005 (x)     |
|    +- Factor ------------------------> Math.005 (x)                      |
|         Math.005 output --------------> Distribute Points on Faces.001   |
|                                          (Density socket)                |
|  Distribute Points on Faces.001 -----> Instance on Points.001            |
|  Object Info.001 (GEO-pebble.004) --> Instance on Points.001             |
|  Random Rotation.002 [-pi, +pi]  ----> Instance on Points.001            |
|  Random Value.002 [0.25 - 0.45] -----> Instance on Points.001            |
|  Instance on Points.001 -------------> Join Geometry.003                 |
+--------------------------------------------------------------------------+

+- SMALL PEBBLES LANE -----------------------------------------------------+
|  Source object : GEO-pebble.002                                          |
|  Group Input.003                                                         |
|    +- Geometry ------------------------> Distribute Points on Faces.002  |
|    +- Small Pebbles Mask -----------> Math.006 (x) --> Math.007 (x)      |
|    +- Factor ------------------------> Math.006 (x)                      |
|         Math.007 output --------------> Distribute Points on Faces.002   |
|                                          (Density socket)                |
|  Distribute Points on Faces.002 -----> Instance on Points.002            |
|  Object Info.002 (GEO-pebble.002) --> Instance on Points.002             |
|  Random Rotation [-pi, +pi]      ----> Instance on Points.002            |
|  Random Value.003 [0.10 - 0.35] -----> Instance on Points.002            |
|  Instance on Points.002 -------------> Join Geometry.003                 |
+--------------------------------------------------------------------------+

+- MERGE & OUTPUT ---------------------------------------------------------+
|  Group Input.004                                                         |
|    +- Geometry (pass-through) --------> Join Geometry.003                |
|  Join Geometry.003                                                       |
|    (inputs: large instances + medium instances +                         |
|             small instances  + original ground geo)                      |
|    +- Geometry -----------------------> Group Output                     |
+--------------------------------------------------------------------------+

SCALE RANGES (uniform, per lane)
---------------------------------
  Large  pebbles : 0.25 - 0.60
  Medium pebbles : 0.25 - 0.45
  Small  pebbles : 0.10 - 0.35

ROTATION (all lanes)
---------------------
  All three axes randomised independently over [-pi, +pi],
  giving each pebble instance a fully random orientation.

DENSITY CONTROL PATTERN (Medium & Small lanes)
-----------------------------------------------
  The mask value and the Factor are first multiplied together
  (Math.004 / Math.006), then that product is multiplied again
  by a second value (Math.005 / Math.007) before being fed into
  the Density socket.  This two-stage multiply gives a non-linear
  response curve, making the density fall off more aggressively
  near the mask edges.

  The Large lane uses a different (single-stage) approach:
  the Density Factor socket receives the mask directly, and the
  Factor is only used to scale Density Max via Math.003.

NOTES & SUGGESTIONS
--------------------
  * The node group has no Seed input exposed; adding one would allow
    re-randomising all three layers simultaneously without touching
    individual nodes.
  * The Factor input currently appears three times (once per lane).
    Merging them into a single shared socket would simplify the
    modifier panel.
  * Consider labelling the unlabelled Math nodes (Math.003-.007)
    and Random Value nodes to aid future maintenance.