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.org

O que você pode fazer com Blender MCP?

Analisar desempenho da cena — Peça ao assistente para encontrar objetos com a maior contagem de polígonos em relação ao tamanho na tela a partir da visão da câmera.
Renomear data-blocks — Corrigir erros de digitação ou aplicar convenções de nomenclatura descritivas em objetos, luzes, câmeras, texturas e outros data-blocks.
Consultar relações de dados — Use linguagem natural para perguntar quais objetos usam um material específico ou como os data-blocks estão conectados.
Depurar problemas da cena — Identificar objetos com a maior contagem de polígonos, malhas não-manifold ou outros problemas comuns no arquivo aberto.
Documentar configurações de Geometry Nodes — Gerar quadros de documentação inline e um data-block de texto explicando o que um grupo de nós faz e como está estruturado.

Documentação

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

Aviso de Segurança
O servidor MCP executará código gerado por LLM no Blender sem nenhuma proteção para impedir que seus dados sejam removidos ou enviados para um local remoto. Para manter seus dados seguros, recomenda-se usar uma máquina virtual ou um sistema sem acesso a informações sensíveis.

Instalação

O Blender não possui nenhuma funcionalidade nativa para conectar-se a LLMs.

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

Requisitos:

Blender 5.1 ou mais recente
Add-on
Cliente LLM
Servidor MCP

Add-on

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

Arraste e solte no Blender

…ou baixe e instale a partir do disco

Se você arrastar e soltar no Blender, precisará fazer isso duas vezes. Primeiro para adicionar o repositório Blender Lab e, em seguida, para instalar o add-on propriamente dito. Este 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 das capacidades do seu cliente LLM.

Pacote MCP: Para clientes mais recentes que suportam arquivos .mcpb, baixe o pacote mais recente da página de lançamento. O Llama.cpp ainda não oferece suporte para 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. Veja, por exemplo, o arquivo de demonstração Classroom:

Arquivo de demonstração Classroom.

Esta cena é um dos arquivos de 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 possam conter objetos propensos a serem otimizados.

Embora verificar a contagem de polígonos muitas vezes seja 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:

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

O objeto alphabet tem 20 mil polígonos. Devido à sua disposição plana, 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 no seu sistema.

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

Quão confiáveis são esses resultados?

A análise inicial retornada pelo LLM considerou apenas os modificadores que influenciavam a viewport. O objeto coat 1 tem um modificador Solidify que duplica sua contagem de polígonos, tornando-o um ponto fora da curva ainda maior. E embora esta cena não tivesse a Simplificação ativada, 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
Renomeação de blocos de dados: corrigir erros de digitação	Com o arquivo Blender atualmente aberto, corrija o nome de todos os blocos de dados para remover erros de digitação. Relate quais blocos de dados foram corrigidos.	Scattering Pebbles	GRP-rocks → GRP-pebble, LGT-Lights → LGT-lights, Compositing Nodetree → Compositing Node Tree
Renomeação de blocos de dados: nomes melhores	Com o arquivo Blender atualmente aberto, sugira nomes descritivos para todos os blocos de dados e aplique se aprovado.	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, …
Consultando relações de dados usando linguagem natural	Quais objetos estão usando o seguinte 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	Qual é o objeto com a maior contagem de polígonos neste arquivo? Ignore objetos que não estão vinculados a nenhuma cena.	Scattering Pebbles	GEO-ground com 4.096 faces.
Documentação de Geometry Nodes	Com o arquivo Blender atualmente aberto, explique o que a configuração principal de geometry nodes está fazendo. Adicione documentação inline para ela com elementos de frame. Crie um bloco de dados de Texto com o resultado da análise.	Scattering Pebbles	4 frames principais codificados por cores + arquivo de texto com explicação.

Outros prompts ainda a serem explorados:

Traduzir todos os blocos de dados de Francês para 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 de sombreamento estranhos, como posso corrigir isso?
Encontrar objetos que possuem malhas com normais ruins.
Verificar minha cena em busca de objetos de malha transformados não uniformemente.
O vídeo que exportei não reproduz nos meus navegadores web, quais configurações devo alterar?
Quais pincéis de escultura devo usar para criar e detalhar galhos de árvores?
Configurar nós de composição para salvar minha imagem tanto como SDR quanto HDR.
Verificar esta lista de verificação: as malhas devem ser manifold, todos os objetos devem ter materiais, a nomenclatura deve seguir a convenção, sem caminhos absolutos, … Renomeação de blocos de dados: corrigir erros de digitação

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

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

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

Renomeação de blocos de dados: 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

Blocos de Dados de Luz:

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

Bloco de Dados 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 Frames criados:

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

Bloco de Dados 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.