Como Conectar Claude e Cursor Diretamente ao Unity via MCP

https://github.com/IvanMurzak/Unity-MCP/raw/main/docs/img/promo/ai-developer-banner.jpg

A maioria dos desenvolvedores está acostumada a tratar redes neurais como uma área de transferência inteligente. Copiamos um erro do console para um chat com um modelo, recebemos um script C# corrigido de volta e colamos no projeto. Mas quando você precisa fazer mais do que apenas reescrever uma classe — quando precisa posicionar trinta prefabs em um círculo, criar uma dúzia de materiais ou executar testes rapidamente diretamente no editor — esse pingue-pongue começa consumindo tempo demais.

O repositório Unity-MCP resolve essa rotina de forma fundamental. O projeto conecta o Unity com assistentes populares via Model Context Protocol. Este é um padrão aberto da Anthropic que transforma um modelo de linguagem de um consultor passivo em um executor ativo dentro do seu ambiente de desenvolvimento.

https://github.com/IvanMurzak/Unity-MCP/blob/main/docs/img/editor/ai-game-developer-windows.png?raw=true

O que Unity e MCP Podem Fazer Juntos

O repositório inclui mais de 70 ferramentas prontas, organizadas em grupos lógicos. O assistente obtém acesso à estrutura de arquivos, hierarquia de cenas, compilador Roslyn e até mesmo ao profiler.

Você pode escrever no Cursor ou Claude Code uma frase simples: "Crie três esferas empilhadas uma sobre a outra e aplique um material metálico dourado a elas." O modelo chamará as APIs necessárias por conta própria, criará o asset de material, configurará os parâmetros do shader e adicionará os objetos à cena.

https://github.com/IvanMurzak/Unity-MCP/blob/main/docs/img/editor/setup-skills.jpg?raw=true

Aqui estão os principais grupos de operações que o plugin manipula:

• Gerenciamento de assets e pacotes via UPM
• Manipulação de GameObjects, componentes e prefabs
• Execução de testes em EditMode e PlayMode com entrega de relatórios de volta ao chat
• Execução dinâmica de código C# via Roslyn sem recompilação demorada
• Captura de screenshots da câmera ou Scene View para avaliação visual de resultados
• Coleta de métricas de performance e memória através do profiler integrado

O suporte a reflection é particularmente interessante. A rede neural pode encontrar métodos no código e chamá-los com os argumentos necessários, mesmo que esses métodos sejam privados ou estejam localizados em DLLs externas.

Como o Servidor e a Troca de Dados Funcionam

A arquitetura consiste em duas partes: um plugin C# para Unity e um servidor MCP separado que é executado como binário ou container Docker. O cliente (por exemplo, Claude Desktop ou VS Code) se comunica com o servidor via protocolo stdio ou HTTP, e o servidor passa os comandos para a instância do Unity em execução.

https://github.com/IvanMurzak/Unity-MCP/raw/main/docs/img/ai-connector-window.gif

Início Rápido via CLI

O projeto inclui um pacote CLI conveniente que automatiza a instalação do plugin e a geração de skills para os modelos:

npm install -g unity-mcp-cli
unity-mcp-cli install-plugin ./MyUnityProject
unity-mcp-cli open ./MyUnityProject

Se CLI não é o seu caso, você pode baixar um .unitypackage pronto do GitHub releases ou adicionar o pacote via OpenUPM.

Observe o requisito estrito de caminho. O caminho para o seu projeto Unity não pode conter espaços, caso contrário o servidor local simplesmente recusará funcionar.

Criando Ferramentas Personalizadas

O plugin é fácil de estender. Para dar à rede neural acesso à lógica específica do seu jogo, você só precisa escrever um método C# regular e marcá-lo com os atributos AiToolType e AiTool.

Qualquer chamada à API do Unity precisa ser envolvida em execução na main thread, porque as requisições recebidas do servidor chegam em uma thread em segundo plano:

[AiToolType]
public class LevelBuildingTools
{
    [AiTool("spawn-enemy-wave", Title = "Spawn Enemy Wave")]
    [Description("Спавнит волну врагов заданного типа в указанных координатах")]
    public string SpawnWave(
        [Description("Имя префаба врага")] string enemyType,
        [Description("Количество врагов")] int count
    )
    {
        return MainThread.Instance.Run(() =>
        {
            EnemySpawner.Instance.Spawn(enemyType, count);
            return $"Успешно заспавнено {count} врагов типа {enemyType}";
        });
    }
}

Os atributos Description desempenham um papel crítico. O modelo lê essas descrições para entender quando chamar a ferramenta e quais tipos de dados passar como argumentos.

Trabalhando em Runtime e Builds

A maioria das integrações similares é limitada ao modo Editor. O autor do Unity-MCP foi além e adicionou um cliente runtime. Você pode embedar o servidor diretamente em um jogo compilado para entregar o controle de NPCs a um modelo de linguagem.

Aqui está como fica a inicialização do plugin runtime em código:

var mcpPlugin = UnityMcpPluginRuntime.Initialize(builder =>
    {
        builder.WithConfig(config =>
        {
            config.Host = "http://localhost:8080";
            config.Token = "your-token";
        });
        builder.WithToolsFromAssembly(Assembly.GetExecutingAssembly());
    })
    .Build();

await mcpPlugin.Connect();

O repositório inclui um exemplo de chess bot onde toda a lógica de movimento é delegada a um LLM externo. O modelo requisita o estado atual do tabuleiro via uma MCP Tool e envia de volta a próxima jogada.

Cenários Práticos

Na prática, a ferramenta mostra seus melhores resultados em três áreas:

Primeiro, layout rotineiro de níveis e UI. Montar uma cena básica a partir de uma descrição em texto é muitas vezes mais rápido do que posicionar primitivas manualmente.

Segundo, testes automatizados e busca de bugs. O modelo pode executar testes em EditMode, ler o stack trace de um teste falho, abrir o script fonte, corrigir o erro e executar a verificação novamente.

Terceiro, profiling. As ferramentas de memória e renderização entregam números precisos de timing de frame diretamente no contexto do modelo, o que ajuda a localizar gargalos rapidamente.

Quem Encontrará Este Projeto Útil Agora

Se você está trabalhando em protótipos sozinho ou executando um projeto indie pequeno, o Unity-MCP economizará muito tempo em tarefas rotineiras. A barreira de entrada é mínima: instale o CLI, escolha seu editor de código favorito e você imediatamente obtém um assistente funcional com acesso à cena.

Para equipes enterprise com dezenas de desenvolvedores, a solução exigirá algum cuidado. Você precisará bloquear configurações através das project settings e monitorar direitos de acesso se o servidor for implantado remotamente em Docker. O repositório é ativamente desenvolvido, usa a licença open source Apache 2.0 e aceita pull requests.