Blender MCP

oficial

Un servidor MCP (Model Context Protocol) ligero para Blender. Ofrece una interfaz de lenguaje natural con la API de Python de Blender, mejorando el acceso a la documentación y permitiendo a los usuarios explorar y comprender configuraciones complejas.

Ver en blender.org

¿Qué puedes hacer con Blender MCP?

Analizar el rendimiento de la escena — Pídele al asistente que encuentre objetos con la mayor cantidad de polígonos en relación con su tamaño en pantalla desde la vista de la cámara.
Renombrar bloques de datos — Corrige errores tipográficos o aplica convenciones de nomenclatura descriptivas en objetos, luces, cámaras, texturas y otros bloques de datos.
Consultar relaciones de datos — Usa lenguaje natural para preguntar qué objetos usan un material específico o cómo están conectados los bloques de datos.
Depurar problemas de la escena — Identifica objetos con la mayor cantidad de polígonos, mallas no manifold u otros problemas comunes en el archivo abierto.
Documentar configuraciones de Geometry Nodes — Genera marcos de documentación en línea y un bloque de datos de texto que explique qué hace un grupo de nodos y cómo está estructurado.

Documentación

Un servidor MCP (Model Context Protocol) ligero para Blender. Ofrece una interfaz en lenguaje natural con la API de Python de Blender, mejorando el acceso a la documentación y permitiendo a los usuarios explorar y comprender configuraciones complejas.

Para detalles técnicos y documentación sobre la arquitectura, consulta el código fuente.

Advertencia de seguridad
El servidor MCP ejecutará código generado por LLM en Blender sin ninguna protección para evitar que tus datos sean eliminados o enviados a una ubicación remota. Para mantener tus datos seguros, se recomienda usar una máquina virtual o un sistema sin acceso a información sensible.

Instalación

Blender no tiene ninguna funcionalidad integrada para conectarse a LLMs.

Para que Blender se conecte con LLMs, se deben descargar, instalar y ejecutar manualmente tres herramientas externas.

Requisitos:

Blender 5.1 o más reciente
Complemento (Add-on)
Cliente LLM
Servidor MCP

Complemento (Add-on)

Para interactuar con tu sesión de Blender, necesitas instalar un complemento específico para la integración con el Servidor MCP.

Arrastrar y soltar en Blender

…o descargar e instalar desde el disco

Si arrastras y sueltas en Blender, necesitarás hacerlo dos veces. La primera para añadir el repositorio Blender Lab, y la segunda para instalar el complemento en sí. Este método te permite recibir notificaciones de actualización cuando haya una nueva versión disponible de este complemento.

Cliente LLM

Los Servidores MCP siguen un estándar bien definido y son compatibles con una gran variedad de clientes. Sigue la documentación de LLama.cpp o instala un cliente LLM de tu preferencia.

Servidor MCP

Hay diferentes formas de instalar el Servidor MCP dependiendo de las capacidades de tu cliente LLM.

Paquete MCP: Para clientes más nuevos que soportan archivos .mcpb, descarga el último paquete desde la página de lanzamientos. Llama.cpp aún no soporta esto.
Servidor MCP: Para instalar desde el código fuente, consulta la documentación de Llama.cpp o las instrucciones de configuración.

Ejecución

Una vez que tengas configurado tu Servidor MCP dentro de tu Cliente LLM, puedes empezar a explorar tus escenas de Blender.

Interfaz web de llama.cpp ejecutando el servidor blender-mcp.

Ejemplo 1: Análisis de escena

MCP puede usarse para analizar programáticamente la escena en busca de cuellos de botella de rendimiento. Tomemos como ejemplo el archivo de demostración del Aula:

Archivo de demostración del aula.

Esta escena es uno de los archivos de referencia de Blender. La razón por la que estos archivos están en el benchmark es porque son una buena representación de archivos de producción reales creados por artistas. Y no es sorpresa que pueda contener objetos propensos a ser optimizados.

Si bien verificar el número de polígonos suele ser suficiente, es aún más interesante graficar la cantidad de polígonos en función de qué tan grandes se muestran en el render final. Esto se puede obtener con el siguiente prompt.

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

Los datos resultantes graficados muestran claramente dos objetos que se destacan del resto: alphabet y coat 1:

Análisis gráfico del número de polígonos por área de pantalla para la escena de demostración del aula.

El objeto alphabet tiene 20k polígonos. Debido a su disposición plana, podría reemplazarse por una textura con pocas desventajas para el resultado final. El objeto coat 1 tiene 37k polígonos debido a su modificador Subsurf. Bajar el nivel de subdivisión podría aliviar la escena, si la memoria fuera el cuello de botella en tu sistema.

El alfabeto se sitúa al fondo de la escena y podría reemplazarse fácilmente por una textura. El abrigo también está lo suficientemente lejos como para que su malla pueda simplificarse.

¿Qué tan fiables son esos resultados?

El análisis inicial devuelto por el LLM solo consideró los modificadores que influían en la vista 3D. El objeto coat 1 tiene un modificador Solidify que duplica su número de polígonos, convirtiéndolo en un valor aún más atípico. Y aunque esta escena no tenía la opción Simplificar habilitada, esta configuración también habría afectado el análisis final.

Ejemplo 2: Varios Prompts

Estos son algunos de los otros casos de uso probados. Necesitarás pegar el contenido completo del “Prompt” para que funcionen. Como punto de partida, deberías usar el archivo de demostración correspondiente. El éxito de la operación dependerá del modelo utilizado.

Caso de Uso	Prompt	Archivo Demo	Resultado
Renombrar bloques de datos: corregir erratas	Con el archivo de Blender actualmente abierto, corrige el nombre de todos los bloques de datos para eliminar erratas. Informa qué bloques de datos fueron corregidos.	Scattering Pebbles	GRP-rocks → GRP-pebble, LGT-Lights → LGT-lights, Compositing Nodetree → Compositing Node Tree
Renombrar bloques de datos: mejores nombres	Con el archivo de Blender actualmente abierto, sugiere nombres descriptivos para todos los bloques de datos y aplícalos si se aprueban.	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, …
Consultar relaciones de datos usando lenguaje natural	¿Qué objetos están usando el siguiente material: pebbles?	Scattering Pebbles	7 objetos: GEO-pebble, GEO-pebble.001, GEO-pebble.002, GEO-pebble.003, GEO-pebble.004, GEO-pebble.005, GEO-pebble.006
Depuración de escena	¿Cuál es el objeto con el mayor número de polígonos en este archivo? Ignora los objetos que no estén vinculados a ninguna escena.	Scattering Pebbles	GEO-ground con 4,096 caras.
Documentación de Nodos de Geometría	Con el archivo de Blender actualmente abierto, explica qué está haciendo la configuración principal de nodos de geometría. Añade documentación en línea con elementos de marco. Crea un bloque de datos de Texto con el resultado.	Scattering Pebbles	4 marcos principales codificados por colores + archivo de texto con explicación.

Otros prompts aún por explorar:

Traducir todos los bloques de datos de francés a inglés.
Mi malla no está siendo deformada por mi armadura, ¿cómo puedo arreglarlo?
Blender se está quedando sin memoria al renderizar esta escena, ¿cómo puedo optimizarla?
Esta malla tiene artefactos de sombreado extraños, ¿cómo puedo arreglarlo?
Encontrar objetos que tengan mallas con normales incorrectas.
Revisar mi escena en busca de objetos de malla transformados no uniformemente.
El video que exporté no se reproduce en mis navegadores web, ¿qué ajustes debo cambiar?
¿Qué pinceles de esculpido debo usar para crear y detallar ramas de árboles?
Configurar nodos de composición para guardar mi imagen tanto en SDR como en HDR.
Verificar esta lista de comprobación: las mallas deben ser manifold, todos los objetos deben tener materiales, los nombres deben seguir la convención, sin rutas absolutas, … Renombrar bloques de datos: corregir erratas

GRP-rocks → GRP-pebbles (la escena solo contiene objetos de guijarro, no rocas).

LGT-Lights → LGT-lights (uso inconsistente de mayúsculas/minúsculas).

Compositing Nodetree → Compositing Node Tree (Nodetree es un error de palabra compuesta).

Renombrar bloques de datos: mejores nombres

Objetos:

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

Bloques de datos de luz:

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

Bloque de datos de cámara:

Camera → CAM-main

Texturas:

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

Escena y Mundo:

World → WLD-environment
Scene → SCN-main Documentación de Nodos de Geometría

Nuevos marcos creados:

Marcos de documentación añadidos a la configuración de nodos de geometría.

Bloque de datos de texto:

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.