Blender MCP

oficial

Um servidor MCP (Model Context Protocol) leve para o Blender. Ele oferece uma interface em linguagem natural com a API Python do Blender, melhorando o acesso à documentação e permitindo que os usuários explorem e entendam configurações complexas.

Ver em blender.orgExperimente este MCPPatrocinado

O que você pode fazer com Blender MCP?

Análise de desempenho da cena — Peça à sua IA para analisar a cena aberta no Blender e identificar objetos com alta contagem de polígonos em relação ao tamanho na tela, como a detecção de outliers do exemplo da sala de aula.
Renomeação de data-blocks — Peça ao assistente para corrigir erros de digitação ou sugerir nomes descritivos para todos os data-blocks do arquivo atual, aplicando as alterações somente após sua aprovação.
Consultas de cena em linguagem natural — Faça perguntas sobre relacionamentos entre objetos, como "Quais objetos estão usando o material 'pebbles'?" ou identifique o objeto com maior contagem de polígonos na cena.
Documentação de Geometry Nodes — Solicite uma explicação da configuração principal dos geometry nodes, com documentação inline nos frames e um data-block de texto resumindo a análise.
Depuração de cena — Obtenha ajuda para solucionar problemas como malhas com escala não uniforme, normais incorretas ou objetos que não deformam corretamente com armaduras.

Documentação

Um servidor MCP (Model Context Protocol) leve para Blender. Ele oferece uma interface em linguagem natural com a API Python do Blender, melhorando o acesso à documentação e permitindo que os usuários explorem e entendam configurações complexas.

Para detalhes técnicos e documentação sobre a arquitetura, consulte o código-fonte.

[!warning] Aviso Aviso de Segurança
O servidor MCP executará código gerado por LLM no Blender sem quaisquer proteções para impedir a remoção dos seus dados ou o envio deles para um local remoto. Para manter seus dados seguros, é recomendado usar uma máquina virtual ou um sistema sem acesso a informações sensíveis.

Instalação

O Blender não possui nenhuma funcionalidade integrada para conexão com LLMs.

Para que o Blender se conecte a LLMs, três ferramentas externas devem ser baixadas, instaladas e executadas manualmente.

Add-on

Para interagir com sua sessão do Blender, você precisa instalar um add-on específico para a integração do servidor MCP.

…ou baixe e Instale pelo Disco

Se você arrastar e soltar no Blender, será necessário fazer isso duas vezes. Primeiro para adicionar o repositório do Blender Lab, e depois para instalar o add-on em si. Esse método permite que você receba notificações de atualização sempre que uma nova versão deste add-on estiver disponível.

Cliente LLM

Os servidores MCP seguem um padrão bem definido e são compatíveis com uma infinidade de clientes. Siga a documentação do LLama.cpp ou instale um cliente LLM de sua preferência.

Servidor MCP

Existem diferentes maneiras de instalar o servidor MCP, dependendo dos recursos do seu cliente LLM.

Pacote MCP: Para clientes mais novos que suportam arquivos .mcpb, baixe o pacote mais recente na página de releases. O Llama.cpp ainda não suporta isso.
Servidor MCP: Para instalar a partir do código-fonte, consulte a documentação do Llama.cpp ou as instruções de configuração.

Execução

Depois de configurar seu servidor MCP no seu cliente LLM, você pode começar a explorar suas cenas do Blender.

Interface web do llama.cpp executando o servidor blender-mcp.

Exemplo 1: Análise de Cena

O MCP pode ser usado para analisar programaticamente a cena em busca de gargalos de desempenho. Tome como exemplo o arquivo de demonstração Classroom:

Arquivo de demonstração Classroom.

Esta cena é um dos arquivos do benchmark do Blender. A razão pela qual esses arquivos estão no benchmark é porque eles são uma boa representação de arquivos de produção reais criados por artistas. E não é surpresa que possa conter objetos propensos a otimização.

Embora verificar a contagem de polígonos seja muitas vezes suficiente, é ainda mais interessante plotar o número de polígonos com base no tamanho que eles aparecem na renderização final. Isso pode ser obtido com o seguinte prompt.

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

Os dados resultantes plotados mostram claramente dois objetos que se destacam dos demais: alphabet e coat 1:

Graph analysis of the polycount per screen area

Análise gráfica da contagem de polígonos por área de tela para a cena de demonstração do classroom.

O objeto alphabet tem 20 mil polígonos. Devido à sua disposição plana, ele poderia ser substituído por uma textura com pouca desvantagem para o resultado final. O objeto coat 1 tem 37 mil polígonos devido ao seu modificador Subsurf. Reduzir o nível de subdivisão poderia aliviar a cena, se a memória fosse o gargalo do seu sistema.

O alfabeto fica ao fundo da cena e poderia facilmente ser substituído por uma textura. O casaco também está distante o suficiente para ter sua malha simplificada.

[!info] Informação Quão confiáveis são esses resultados?

A análise inicial retornada pelo LLM considerou apenas os modificadores que influenciam o viewport. O objeto coat 1 tem um modificador Solidify que dobra sua contagem de polígonos, tornando-o um outlier ainda maior. E embora esta cena não tivesse o Simplify ativado, essa configuração também teria afetado a análise final.

Exemplo 2: Vários Prompts

Estes são alguns dos outros casos de uso testados. Você precisará colar todo o conteúdo do "Prompt" para que funcionem. Como ponto de partida, você deve usar o arquivo de demonstração correspondente. O sucesso da operação dependerá do modelo utilizado.

Caso de Uso	Prompt	Arquivo de Demonstração	Resultado
Renomear data-blocks: corrigir erros de digitação	`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
Renomear data-blocks: nomes melhores	`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, …
Consultar relações de dados usando linguagem natural	`Which objects are using the following 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
Depuração de cena	`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 com 4.096 faces.
Documentação de Geometry Nodes	`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 quadros principais codificados por cores + arquivo de texto com explicação.

Outros prompts ainda a serem explorados:

Traduzir todos os data-blocks do francês para o inglês.
Minha malha não está sendo deformada pelo meu armature, como posso corrigir isso?
O Blender está ficando sem memória ao renderizar esta cena, como posso otimizá-la?
Esta malha tem artefatos estranhos de sombreamento, como posso corrigir isso?
Encontre objetos que tenham malhas com normais ruins.
Verifique minha cena em busca de objetos de malha com transformações não uniformes.
O vídeo que exportei não reproduz nos meus navegadores, quais configurações devo alterar?
Quais pincéis de escultura devo usar para criar e detalhar galhos de árvores?
Configure nós de compositing para salvar minha imagem tanto em SDR quanto em HDR.
Verifique esta lista de verificação: malhas devem ser manifold, todos os objetos devem ter materiais, a nomenclatura deve seguir a convenção, sem caminhos absolutos, … Renomear data-blocks: corrigir erros de digitação

GRP-rocks → GRP-pebbles (a cena contém apenas objetos pebble, não rocks).

LGT-Lights → LGT-lights (capitalização inconsistente).

Compositing Nodetree → Compositing Node Tree (Nodetree é um erro de palavra composta).

Renomear data-blocks: nomes melhores

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

Data-Blocks de Luz:

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

Data-Block de Câmera:

Camera → CAM-main

Texturas:

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

Cena e Mundo:

World → WLD-environment
Scene → SCN-main Documentação de Geometry Nodes

Novos quadros criados:

Documentation frames added to the geometry nodes setup.

Quadros de documentação adicionados à configuração de geometry nodes.

Data-block 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.