Blender MCP

officiel

Un serveur MCP (Model Context Protocol) léger pour Blender. Il offre une interface en langage naturel avec l'API Python de Blender, améliorant l'accès à la documentation et permettant aux utilisateurs d'explorer et de comprendre des configurations complexes.

Voir sur blender.orgEssayer ce MCPSponsorisé

Que pouvez-vous faire avec Blender MCP ?

Analyse des performances de la scène — Demandez à votre IA d’analyser la scène Blender ouverte et d’identifier les objets ayant un nombre de polygones élevé par rapport à leur taille à l’écran, comme la détection des valeurs aberrantes dans l’exemple de la salle de classe.
Renommage des data-blocks — Faites corriger les fautes de frappe ou suggérer des noms descriptifs pour tous les data-blocks du fichier actuel, en appliquant les modifications uniquement après votre approbation.
Requêtes de scène en langage naturel — Posez des questions sur les relations entre objets, comme « Quels objets utilisent le matériau 'pebbles' ? » ou identifiez l’objet avec le plus grand nombre de polygones dans la scène.
Documentation des Geometry Nodes — Demandez une explication de la configuration principale des geometry nodes, avec une documentation intégrée aux frames et un data-block texte résumant l’analyse.
Débogage de scène — Obtenez de l’aide pour résoudre des problèmes tels que des maillages mis à l’échelle de manière non uniforme, des normales incorrectes ou des objets qui ne se déforment pas correctement avec les armatures.

Documentation

Un serveur MCP (Model Context Protocol) léger pour Blender. Il offre une interface en langage naturel avec l’API Python de Blender, améliorant l’accès à la documentation et permettant aux utilisateurs d’explorer et de comprendre des configurations complexes.

Pour les détails techniques et la documentation sur l’architecture, consultez le code source.

[!warning] Avertissement Avertissement de sécurité
Le serveur MCP exécutera du code généré par LLM dans Blender sans aucune protection pour empêcher la suppression de vos données ou leur envoi vers un emplacement distant. Pour protéger vos données, il est recommandé d’utiliser une machine virtuelle ou un système sans accès à des informations sensibles.

Installation

Blender ne dispose d’aucune fonctionnalité intégrée pour se connecter aux LLM.

Pour que Blender puisse se connecter aux LLM, trois outils externes doivent être téléchargés, installés et exécutés manuellement.

Add-on

Pour interagir avec votre session Blender, vous devez installer un add-on spécifique pour l’intégration du serveur MCP.

…ou télécharger et installer depuis le disque

Si vous faites un glisser-déposer dans Blender, vous devrez le faire deux fois. D’abord pour ajouter le dépôt Blender Lab, ensuite pour installer l’add-on lui-même. Cette méthode vous permet de recevoir des notifications de mise à jour à chaque nouvelle version de cet add-on.

Client LLM

Les serveurs MCP suivent un standard bien défini et sont compatibles avec une multitude de clients. Veuillez suivre la documentation de LLama.cpp, ou installer un client LLM de votre choix.

Serveur MCP

Il existe différentes façons d’installer le serveur MCP selon les capacités de votre client LLM.

Bundle MCP : Pour les clients plus récents prenant en charge les fichiers .mcpb, téléchargez le dernier package depuis la page des versions. Llama.cpp ne prend pas encore cela en charge.
Serveur MCP : Pour installer à partir du code source, consultez la documentation Llama.cpp ou les instructions d’installation.

Exécution

Une fois votre serveur MCP configuré dans votre client LLM, vous pouvez commencer à explorer vos scènes Blender.

Interface web llama.cpp exécutant le serveur blender-mcp.

Exemple 1 : Analyse de scène

MCP peut être utilisé pour analyser programmatiquement la scène afin de détecter les goulots d’étranglement de performance. Prenons par exemple le fichier de démonstration Classroom :

Fichier de démonstration Classroom.

Cette scène est l’un des fichiers du benchmark Blender. La raison pour laquelle ces fichiers font partie du benchmark est qu’ils représentent bien les fichiers de production réels créés par des artistes. Il n’est pas surprenant qu’ils puissent contenir des objets susceptibles d’être optimisés.

Bien que vérifier le nombre de polygones soit souvent suffisant, il est encore plus intéressant de tracer le nombre de polygones en fonction de leur taille à l’écran dans le rendu final. Cela peut être obtenu avec l’invite suivante.

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

Les données tracées résultantes montrent clairement deux objets qui se démarquent des autres : alphabet et coat 1 :

Graph analysis of the polycount per screen area

Analyse graphique du nombre de polygones par zone d’écran pour la scène de démonstration Classroom.

L’objet alphabet a 20 000 polygones. En raison de sa disposition plate, il pourrait être remplacé par une texture avec peu d’impact sur le résultat final. L’objet coat 1 a 37 000 polygones en raison de son modificateur Subsurf. Réduire le niveau de subdivision pourrait alléger la scène, si la mémoire était le goulot d’étranglement de votre système.

L’alphabet se trouve à l’arrière de la scène et pourrait facilement être remplacé par une texture. Le manteau est également assez éloigné pour que son maillage puisse être simplifié.

[!info] Info Dans quelle mesure ces résultats sont-ils fiables ?

L’analyse initiale renvoyée par le LLM ne prenait en compte que les modificateurs influençant la vue. L’objet coat 1 possède un modificateur Solidify qui double son nombre de polygones, ce qui en fait un cas encore plus extrême. Et bien que cette scène n’ait pas de paramètre Simplify activé, ce paramètre aurait également affecté l’analyse finale.

Exemple 2 : Diverses invites

Voici quelques autres cas d’utilisation testés. Vous devrez coller l’intégralité du contenu de l’« invite » pour qu’ils fonctionnent. Comme point de départ, vous devez utiliser le fichier de démonstration correspondant. Le succès de l’opération dépendra du modèle utilisé.

Cas d’utilisation	Invite	Fichier de démonstration	Résultat
Renommage de data-blocks : correction de fautes de frappe	`With the current open Blender file fix the name of all the data-blocks to remove typos. Report back which data-blocks got fixed.`	Scattering Pebbles	GRP-rocks → GRP-pebble, LGT-Lights → LGT-lights, Compositing Nodetree → Compositing Node Tree
Renommage de data-blocks : meilleurs noms	`With the current open Blender file suggest descriptive names for all data-blocks, and apply if approved.`	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, …
Interrogation des relations de données en langage naturel	`Which objects are using the following material: pebbles`	Scattering Pebbles	7 objets : GEO-pebble, GEO-pebble.001, GEO-pebble.002, GEO-pebble.003, GEO-pebble.004, GEO-pebble.005, GEO-pebble.006
Débogage de scène	`What is the object with the highest poly-count on this file? Ignore objects which are not linked to any scene.`	Scattering Pebbles	GEO-ground avec 4 096 faces.
Documentation des nœuds de géométrie	`With the current open Blender file explain what the main geometry nodes setup is doing. Add inline documentation for it with frame elements. Create a Text data-block with the result of analysis.`	Scattering Pebbles	4 cadres principaux codés par couleur + fichier texte avec explication.

Autres invites encore à explorer :

Traduire tous les data-blocks du français vers l’anglais.
Mon maillage n’est pas déformé par mon armature, comment puis-je corriger cela ?
Blender manque de mémoire lors du rendu de cette scène, comment puis-je l’optimiser ?
Ce maillage présente d’étranges artefacts d’ombrage, comment puis-je corriger cela ?
Trouver les objets dont les maillages ont de mauvaises normales.
Vérifier ma scène pour les objets maillés avec des transformations non uniformes.
La vidéo que j’ai exportée ne se lit pas dans mes navigateurs web, quels paramètres dois-je modifier ?
Quels pinceaux de sculpture dois-je utiliser pour créer et détailler des branches d’arbres ?
Configurer les nœuds de compositing pour enregistrer mon image à la fois en SDR et en HDR.
Vérifier cette liste de contrôle : les maillages doivent être fermés, tous les objets doivent avoir des matériaux, la dénomination doit suivre la convention, pas de chemins absolus, … Renommage de data-blocks : correction de fautes de frappe

GRP-rocks → GRP-pebbles (la scène ne contient que des objets pebble, pas des rocks).

LGT-Lights → LGT-lights (casse incohérente).

Compositing Nodetree → Compositing Node Tree (Nodetree est une erreur de mot composé).

Renommage de data-blocks : meilleurs noms

Objets :

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

Data-blocks de lumière :

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

Data-block de caméra :

Camera → CAM-main

Textures :

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

Scène et monde :

World → WLD-environment
Scene → SCN-main Documentation des nœuds de géométrie

Nouveaux cadres créés :

Documentation frames added to the geometry nodes setup.

Cadres de documentation ajoutés à la configuration des nœuds de géométrie.

Data-block texte :

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.