SceneView MCP

22 ferramentas para desenvolvimento 3D e AR — gera código SceneView correto e compilável para Android (Jetpack Compose) e iOS (SwiftUI). 858 testes.

GitHub

1.3k

Experimente este MCPPatrocinado

Documentação

sceneview-mcp

Dê a qualquer assistente de IA conhecimento de nível especialista em desenvolvimento 3D e AR.

O servidor oficial do Model Context Protocol para SceneView — o SDK 3D e AR multiplataforma para Android (Jetpack Compose + Filament), iOS / macOS / visionOS (SwiftUI + RealityKit) e Web (Filament.js + WebXR).

Conecte-o ao Claude Code, Cline, Codex, Cursor, GitHub Copilot, JetBrains AI Assistant — ou a qualquer outro cliente MCP — localmente via stdio, ou remotamente via Streamable HTTP em https://mcp.sceneview.dev/mcp (veja Servidor remoto). Seu assistente de IA recebe ferramentas especializadas, exemplos de código compiláveis, a referência completa da API, um validador de código e um widget de visualização 3D integrado — para que ele escreva código 3D/AR correto e funcional na primeira tentativa.

Aviso: O código gerado é fornecido "como está", sem garantia. Sempre revise antes do uso em produção. Consulte TERMS.md e PRIVACY.md.

Início rápido

Um único comando — sem necessidade de instalação:

npx sceneview-mcp

Cada cliente abaixo executa o mesmo servidor. Existem três formatos de configuração no ecossistema — mcpServers (a maioria dos clientes), servers (VS Code) e [mcp_servers.*] (Codex TOML) — mas o comando e os argumentos são idênticos nos três.

Qualquer cliente MCP

{
  "mcpServers": {
    "sceneview": {
      "command": "npx",
      "args": ["-y", "sceneview-mcp"]
    }
  }
}

Claude Code

claude mcp add sceneview -- npx -y sceneview-mcp

Ou faça commit de .mcp.json na raiz do repositório para que todo o time o receba:

{ "mcpServers": { "sceneview": { "type": "stdio", "command": "npx", "args": ["-y", "sceneview-mcp"] } } }

Opcionalmente, o plugin SceneView para Claude Code inclui este servidor com 11 comandos de contribuição com namespace e lembretes multiplataforma:

/plugin marketplace add sceneview/claude-marketplace
/plugin install sceneview@sceneview

Claude Desktop

Configurações → Desenvolvedor → Editar Configuração e adicione o bloco padrão mcpServers acima em ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) ou %APPDATA%\Claude\claude_desktop_config.json (Windows). Reinicie após salvar.

Cline

Ícone de Servidores MCP → Configurar → Configurar Servidores MCP, ou ~/.cline/mcp.json:

{ "mcpServers": { "sceneview": { "command": "npx", "args": ["-y", "sceneview-mcp"], "disabled": false, "autoApprove": [] } } }

Codex

codex mcp add sceneview -- npx -y sceneview-mcp

Ou ~/.codex/config.toml — TOML, e a tabela é mcp_servers, não mcpServers:

[mcp_servers.sceneview]
command = "npx"
args = ["-y", "sceneview-mcp"]

A mesma configuração atende ao Codex CLI, à extensão do IDE e ao aplicativo.

Cursor

Adicione em .cursor/mcp.json (projeto) ou ~/.cursor/mcp.json (global) — o bloco padrão mcpServers acima. O Cursor também aceita um link de instalação:

cursor://anysphere.cursor-deeplink/mcp/install?name=sceneview&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsInNjZW5ldmlldy1tY3AiXX0=

Gemini CLI

A raiz do repositório contém um gemini-extension.json, então o CLI instala o servidor diretamente do GitHub — sem JSON para colar:

gemini extensions install https://github.com/sceneview/sceneview

Isso clona o monorepo inteiro — mais de 2 GB de histórico — porque o CLI instala uma extensão clonando o repositório que a declara, e o manifesto do SceneView está em um repositório que também contém os fontes de Android, Apple, Web, Flutter e React Native. Se você quiser apenas o servidor e não o clone, cole o bloco padrão mcpServers em ~/.gemini/settings.json; é o mesmo comando, npx -y sceneview-mcp, e custa um download do pacote npm.

De qualquer forma, npx resolve sceneview-mcp para a versão mais recente publicada no npm, que não é necessariamente a versão que este manifesto declara — o version do manifesto descreve a extensão, e o servidor que ele inicia é atualizado no ritmo do npm.

A extensão declara apenas o servidor: npx -y sceneview-mcp via stdio, sem arquivo de contexto e sem exclusões de ferramentas, então ela adiciona as ferramentas do SceneView a uma sessão e não altera mais nada nela.

Gemini no Android Studio

A integração MCP do Android Studio não suporta stdio — ela se conecta apenas via HTTP, então aponte-a para o endpoint hospedado. Configurações → Ferramentas → IA → Servidores MCP:

{ "mcpServers": { "sceneview": { "httpUrl": "https://mcp.sceneview.dev/mcp", "enabled": true } } }

GitHub Copilot

No VS Code, .vscode/mcp.json — observe a chave servers, não mcpServers:

{ "servers": { "sceneview": { "type": "stdio", "command": "npx", "args": ["-y", "sceneview-mcp"] } } }

O VS Code também aceita um link de instalação:

vscode:mcp/install?%7B%22name%22%3A%22sceneview%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22sceneview-mcp%22%5D%7D

No Copilot CLI:

copilot mcp add sceneview -- npx -y sceneview-mcp

JetBrains AI Assistant / Junie

Configurações → Ferramentas → AI Assistant → Model Context Protocol (MCP) → Adicionar e cole o bloco padrão mcpServers acima.

MCP Bundle (`.mcpb`)

mcp/manifest.json descreve este servidor no formato MCP Bundle (especificação 0.3), para aplicativos de desktop que instalam um servidor local a partir de um bundle em vez de uma linha de comando. Ele executa o dist/index.js compilado com o Node do host — o host fornece o runtime e nada mais, então o bundle precisa carregar seu próprio node_modules. Compactar este diretório após apenas npm run build produz um bundle que falha na inicialização com Cannot find package '@modelcontextprotocol/sdk':

npm ci                                # dev dependencies — the build needs them
npm run build                         # writes dist/
npm ci --omit=dev --ignore-scripts    # drop the dev tree, keep dist/
zip -r sceneview-mcp.mcpb manifest.json package.json dist node_modules

--ignore-scripts não é opcional: o script prepare deste pacote termina em tsc, e o mesmo comando que omite as dependências de desenvolvimento omite o TypeScript, então sem ele o npm executa prepare, falha ao encontrar tsc e sai com código 127. Reinstale com um npm ci simples depois para restaurar a árvore de desenvolvimento.

O manifesto não é publicado como um artefato .mcpb pelo CI: ele é o descritor, e empacotá-lo continua sendo uma etapa manual para quem precisar de um bundle. mcp/src/packaging.test.ts mantém seu nome, versão, licença, ponto de entrada e faixa de Node iguais aos de package.json — e faz o mesmo para server.json e o gemini-extension.json raiz — porque nada mais perceberia se eles divergissem.

Uso como conector remoto

Sem instalação, nada para executar: o SceneView está hospedado como um servidor MCP remoto em

https://mcp.sceneview.dev/mcp

Qualquer cliente que aceite uma URL MCP Streamable HTTP pode usá-lo. No claude.ai, isso fica em Configurações → Conectores → Adicionar conector personalizado.

Sem autenticação e somente leitura. Não há login, chave de API ou conta: cada ferramenta é uma função pura da própria documentação, exemplos e superfície de API do SDK, então não há nada para autenticar e nada seu armazenado. Todas as ferramentas são anotadas como readOnlyHint, exceto generate_3d_model, que chama um serviço externo de geração e, portanto, é marcada como mundo aberto em vez de somente leitura.

Prefere local? npx -y sceneview-mcp executa exatamente o mesmo servidor via stdio. A rota local é a que lê seu projeto do disco (analyze_project) e a que aceita seus próprios SKETCHFAB_API_KEY / TRIPO_API_KEY; o conector hospedado, por ser compartilhado e anônimo, não pode.

Servidor remoto (Streamable HTTP)

Alguns hosts não conseguem iniciar um processo local: eles precisam do transporte Streamable HTTP do MCP em uma URL pública. O mesmo pacote o serve:

npx sceneview-mcp --http
# [sceneview-mcp] v4.x — HTTP (remote tool surface)
# [sceneview-mcp] MCP endpoint: http://127.0.0.1:3333/mcp

Rota	O que faz
`POST /mcp`	MCP JSON-RPC (Streamable HTTP, sem estado — sem sessões, seguro atrás de qualquer balanceador de carga)
`GET` / `DELETE /mcp`	`405` (sem stream SSE independente, sem sessão para excluir)
`GET /health`	`{"status":"ok","version":"4.x.y"}`
`GET /.well-known/openai-apps-challenge`	Verificação de domínio OpenAI — retorna `OPENAI_APPS_CHALLENGE_TOKEN` como `text/plain`, `404` quando não definido
qualquer outra coisa	`404`

Configuração: PORT (padrão 3333), HOST (padrão 127.0.0.1 — defina HOST=0.0.0.0 para expô-lo e coloque HTTPS na frente), OPENAI_APPS_CHALLENGE_TOKEN (o valor que a OpenAI fornece quando você envia o domínio). O CORS permite qualquer origem. Os controles usuais SKETCHFAB_API_KEY / TRIPO_API_KEY / SCENEVIEW_TELEMETRY=0 se aplicam.

Tudo é gratuito, mas nem tudo é remoto. Três ferramentas de geração (render_3d_preview, create_3d_artifact, generate_scene) precisam das suas próprias credenciais de terceiros, que um endpoint anônimo compartilhado não pode armazenar, então a superfície remota as omite e recusa esses nomes no momento da chamada com uma mensagem clara de isError apontando para o caminho local npx sceneview-mcp. O stdio lista e executa todos os 32.

Visualizador 3D integrado. view_3d_model retorna structuredContent mais _meta.ui.resourceUri = ui://widget/3d-viewer.html; o widget (SceneView.js + Filament.js, servido por resources/read com o tipo MIME text/html;profile=mcp-app e seu _meta.ui.csp) renderiza o modelo inline no ChatGPT e em qualquer host de MCP Apps.

Teste rápido com curl (o cabeçalho Accept é exigido pela especificação):

curl -s http://127.0.0.1:3333/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"curl","version":"0"}}}'
# {"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-11-25","capabilities":{"resources":{},"tools":{}},"serverInfo":{"name":"sceneview-mcp","version":"4.x.y"}}}

Aponte o conector ChatGPT / a ferramenta mcp da OpenAI para https://<your-host>/mcp.

Já hospedado. Você não precisa executá-lo para obter uma URL pública: o mesmo código está implantado em https://mcp.sceneview.dev/mcp (GET /health responde {"status":"ok"}), que é para onde o conector remoto acima aponta. Faça self-host quando quiser suas próprias chaves, seus próprios limites de taxa ou analyze_project contra um checkout local.

O que você obtém

Toda ferramenta é gratuita e não há chave de API. As três ferramentas de geração que falam com um serviço de terceiros usam suas credenciais; todo o resto funciona no momento em que o servidor inicia.

Comece aqui

Seis ferramentas carregam a maior parte do que os assistentes realmente fazem com o SceneView. Se você não ler mais nada:

Ferramenta	O que faz	Pergunte ao seu assistente
`validate_code`	Verifica a compilação do Kotlin ou Swift gerado contra a API pública real — existência de símbolos, mais de 30 regras, sugestões de "você quis dizer" — antes de chegar até você	"Verifique se este código SceneView realmente compila"
`get_node_reference`	A assinatura exata, os padrões e o exemplo para qualquer um dos 48+ tipos de nó, em vez de um inventado	"Quais são os parâmetros de ModelNode?"
`list_samples`	Navegue por 38 cenários por tag (`ar`, `3d`, `ios`, `animation`, `geometry`, …)	"Quais exemplos do SceneView envolvem planos de AR?"
`get_sample`	Retorna um deles completo e compilável, em Kotlin ou Swift	"Me dê o exemplo de posicionamento de plano AR em Kotlin"
`get_setup`	Configuração de Gradle e manifesto para Android 3D ou AR	"Configure o SceneView no meu aplicativo Android"
`get_ar_setup`	Permissões, opções de sessão, detecção de planos, rastreamento de imagens	"Adicione detecção de planos ARCore a esta tela"

Referência completa de ferramentas

Configuração e integração

Ferramenta	O que faz
`get_setup`	Configuração de Gradle + manifesto para Android 3D ou AR
`get_ios_setup`	Dependência SPM, Info.plist, SwiftUI para iOS / macOS / visionOS
`get_web_setup`	Kotlin/JS + Filament.js (WASM) para 3D baseado em navegador
`get_ar_setup`	Permissões, opções de sessão, detecção de planos, rastreamento de imagens
`get_platform_setup`	Guia de configuração unificado para qualquer plataforma (Android, iOS, Web, Flutter, RN, Desktop, TV)

Geração e migração de código

Ferramenta	O que faz
`get_sample`	Retorna um exemplo de código completo e compilável para qualquer um dos 38 cenários (Kotlin ou Swift)
`list_samples`	Navegue por todos os exemplos, filtre por tag (`ar`, `3d`, `ios`, `animation`, `geometry`, ...)
`validate_code`	Verifica o código gerado contra mais de 30 regras — incluindo existência de símbolos contra a API pública real, com sugestões de "você quis dizer" — antes de apresentá-lo ao usuário
`migrate_code`	Migra automaticamente código SceneView 2.x / 3.x com changelog detalhado
`get_migration_guide`	Cada mudança significativa com código antes/depois

Referência da API

Ferramenta	O que faz
`get_node_reference`	Referência completa da API para qualquer um dos 48+ tipos de nó — assinaturas exatas, padrões, exemplos
`list_platforms`	Plataformas suportadas com status, renderizador e framework
`get_platform_roadmap`	Status e cronograma multiplataforma

Guias

get_best_practices · get_animation_guide · get_gesture_guide · get_performance_tips · get_material_guide · get_collision_guide · get_model_optimization_guide · get_web_rendering_guide · get_troubleshooting · debug_issue

Descoberta e análise

Ferramenta	O que faz
`search_models`	Pesquisa modelos 3D gratuitos no Sketchfab (BYOK — defina `SKETCHFAB_API_KEY`)
`generate_3d_model`	Gera um GLB novo a partir de um prompt de texto ou imagem via Tripo AI (BYOK — defina `TRIPO_API_KEY`)
`analyze_project`	Escaneia um projeto SceneView local no disco — detecta a plataforma, extrai a versão, sinaliza dependências desatualizadas e anti-padrões conhecidos
`search_android_docs`	Pesquisa a base de conhecimento de documentação Android do Google (requer o CLI `android` no PATH)
`fetch_android_doc`	Busca uma entrada completa da documentação Android pelo URI `kb://...` (requer o CLI `android` no PATH)

Visualizador 3D inline (widget de apps MCP)

Ferramenta	O que faz
`view_3d_model`	Renderiza uma URL pública de GLB / glTF em um visualizador interativo SceneView.js + Filament.js inline no ChatGPT e em qualquer host de apps MCP (órbita, rotação automática). Para um modelo https, adiciona uma ação "Abrir em AR no seu telefone" (um link `ar.sceneview.dev/open` para o app 3D AR Model Viewer, com código QR no desktop). Retorna `structuredContent` + `_meta.ui.resourceUri`

5 recursos

URI do recurso	O que fornece
`sceneview://api`	Referência completa da API SceneView 4.x (o `llms.txt` completo)
`sceneview://known-issues`	Issues abertas ao vivo do GitHub (cache de 10 min)
`examples://demo-with-settings`	Padrão DemoScaffold v2 — cena em tela cheia + bottom sheet Material 3
`examples://sketchfab-streaming`	Transmissão de modelos Sketchfab CC-BY para uma demo em vez de empacotar GLBs
`ui://widget/3d-viewer.html`	O widget de visualizador 3D (`text/html;profile=mcp-app`) no qual `view_3d_model` renderiza

`search_models` — encontre assets 3D reais a partir da IA

O código SceneView gerado só é útil se apontar para um asset que realmente existe. search_models consulta a API pública de busca do Sketchfab e retorna uma lista com nomes, autores, licenças, miniaturas, contagens de triângulos e URLs de visualizador/embed que o assistente pode inserir diretamente em rememberModelInstance(modelLoader, ...) ou incorporar como pré-visualização ao vivo.

Traga sua própria chave (BYOK). O SceneView nunca faz proxy da solicitação — você mantém o limite de taxa e o custo permanece zero. Para configurar:

Crie uma conta gratuita em sketchfab.com/register
Copie seu token de API de sketchfab.com/settings/password
Defina SKETCHFAB_API_KEY na configuração do seu cliente MCP:

{
  "mcpServers": {
    "sceneview": {
      "command": "npx",
      "args": ["-y", "sceneview-mcp"],
      "env": { "SKETCHFAB_API_KEY": "YOUR_TOKEN_HERE" }
    }
  }
}

Chame como search_models({ query: "red sports car", category: "cars-vehicles", maxResults: 6 }). Se a chave estiver ausente, a ferramenta retorna uma mensagem clara explicando como obter uma, em vez de falhar silenciosamente.

`generate_3d_model` — crie assets 3D novos a partir da IA

Quando nenhum modelo existente serve, generate_3d_model fecha a outra metade do ciclo de assets: ele gera um GLB novo a partir de um prompt de texto (texto→3D) ou de uma imagem de origem (imagem→3D) via API Tripo AI, e então retorna uma URL direta de download do GLB além de metadados de licença/atribuição — pronto para rememberModelInstance(modelLoader, ...) e posicionamento em AR.

Dois níveis de qualidade:

`quality`	Modelo Tripo	Topologia	Latência	Custo aproximado (julho de 2026)
`"fast"` (padrão)	P1 (`P1-20260311`)	low-poly, pronto para AR	~25–30 s	~US$ 0,10–0,25 dos seus créditos
`"hd"`	H3.1 (`v3.1-20260211`)	malha quad, geometria detalhada + texturas	até ~100 s	~US$ 0,41 dos seus créditos

Traga sua própria chave (BYOK). Exatamente como search_models: o SceneView nunca faz proxy da solicitação nem guarda sua chave — as gerações são cobradas na sua conta Tripo. Para configurar:

Crie uma chave de API em platform.tripo3d.ai/api-keys (contas novas ganham créditos de teste gratuitos)
Defina TRIPO_API_KEY na configuração do seu cliente MCP:

{
  "mcpServers": {
    "sceneview": {
      "command": "npx",
      "args": ["-y", "sceneview-mcp"],
      "env": { "TRIPO_API_KEY": "YOUR_KEY_HERE" }
    }
  }
}

Chame como generate_3d_model({ prompt: "a low-poly cactus in a striped pot" }) ou generate_3d_model({ imageUrl: "https://example.com/chair.jpg", quality: "hd" }). Forneça exatamente um de prompt / imageUrl.

⚠️ A URL de download do GLB expira ~5 minutos após a geração — baixe o arquivo imediatamente e hospede-o você mesmo (por exemplo, copie-o para o assets/models/ do seu app). O resultado da ferramenta repete este aviso. Chave ausente, falhas de tarefa, limites de taxa e timeouts de polling (2 min rápido / 4 min limite HD) todos retornam mensagens claras e acionáveis em vez de travar ou falhar.

`analyze_project` — escaneamento de projeto local

Como o servidor MCP roda na máquina do usuário, analyze_project pode ler os arquivos do projeto diretamente. Dado um path (padrão: process.cwd()), ele:

Detecta o tipo de projeto procurando por build.gradle(.kts) com io.github.sceneview:sceneview (Android), Package.swift com SceneViewSwift (iOS) ou package.json com sceneview-web (Web).
Extrai a versão da dependência SceneView e a compara com a versão mais recente conhecida por este build do MCP, sinalizando projetos desatualizados.
Percorre até 30 arquivos de origem (.kt, .kts, .swift, .js, .ts) e até 500 KB no total, escaneando anti-padrões conhecidos: chamadas Filament/ModelLoader dentro de corrotinas em segundo plano, o bug de lambda final LightNode(...) { ... }, APIs 2.x obsoletas (ArSceneView, TransformableNode, PlacementNode, ViewRenderable, loadModelAsync) e imports com.google.ar.sceneform.*.
Retorna um relatório estruturado { projectType, sceneViewVersion, latestVersion, isOutdated, warnings, suggestions }, além de um resumo em Markdown.

A ferramenta é somente leitura, nunca grava no disco e lida graciosamente com diretórios ausentes. Use-a quando o usuário perguntar "meu projeto está atualizado?" ou como uma verificação rápida antes de gerar código novo para uma base de código existente.

Exemplos

"Crie um app de AR para mim"

O assistente chama get_ar_setup + get_sample("ar-model-viewer") e retorna um composable Kotlin completo e compilável com todos os imports, dependências Gradle e entradas de manifest. Pronto para colar no Android Studio.

"Crie um visualizador de modelos 3D para iOS"

O assistente chama get_ios_setup("3d") + get_sample("ios-model-viewer") e retorna código Swift com a dependência SPM, entradas Info.plist e uma visualização SwiftUI funcional.

"Quais parâmetros o LightNode aceita?"

O assistente chama get_node_reference("LightNode") e retorna a assinatura exata da função, tipos de parâmetros, padrões e um exemplo de uso — incluindo o detalhe crítico de que apply é um parâmetro nomeado, não um lambda final.

"Valide este código antes de eu usá-lo"

O assistente chama validate_code com o trecho gerado e o verifica contra 30+ regras: existência de símbolos contra a API pública real (imports desconhecidos, tipos de nós inventados, métodos de loader inexistentes — cada um com sugestões de "você quis dizer"), violações de threading, segurança de nulos, correção de API, problemas de ciclo de vida, APIs obsoletas. Problemas são sinalizados com explicações antes de o código chegar ao usuário.

Por que isso existe

Sem este servidor MCP, assistentes de IA regularmente:

Recomendam Sceneform obsoleto (abandonado em 2021) em vez de SceneView
Geram código imperativo baseado em View em vez de Jetpack Compose
Usam assinaturas de API erradas ou nomes de parâmetros desatualizados
Perdem a pegadinha do parâmetro nomeado LightNode (apply = não é lambda final)
Esquecem verificações de nulo em rememberModelInstance (retorna null durante o carregamento)
Não têm conhecimento algum da API iOS/Swift do SceneView

Com este servidor MCP, assistentes de IA:

Sempre usam a superfície de API atual do SceneView 4.x
Geram código 3D/AR nativo Compose correto para Android
Geram código nativo SwiftUI correto para iOS/macOS/visionOS
Conhecem todos os 48+ tipos de nós e seus parâmetros exatos
Validam código contra 30+ regras antes de apresentá-lo
Fornecem código de exemplo funcional e testado para 38 cenários

Qualidade

O servidor MCP é testado com 2.015 testes unitários em 91 arquivos de teste cobrindo:

Cada resposta de ferramenta (saída correta, tratamento de erros, casos extremos)
Todos os 38 exemplos de código (estrutura compilável, imports corretos, sem APIs obsoletas)
Regras do validador de código (verdadeiros positivos e resistência a falsos positivos)
Análise de referência de nós (todos os tipos de nós extraídos corretamente de llms.txt)
Respostas de recursos (referência de API, integração de issues do GitHub, o widget de visualizador 3D)
A superfície HTTP Streamable de ponta a ponta (inicialização, ferramentas gratuitas/lista, recurso de widget, saúde, desafio OpenAI)

 Test Files  91 passed (91)
      Tests  2015 passed (2015)

Todas as ferramentas funcionam totalmente offline exceto sceneview://known-issues (API do GitHub, cache de 10 min), search_models (Sketchfab, BYOK) e generate_3d_model (Tripo AI, BYOK). A telemetria anônima também faz uma chamada de rede a menos que SCENEVIEW_TELEMETRY=0 (veja abaixo).

Solução de problemas

"Servidor MCP não encontrado" ou erros de conexão

Garanta que o Node.js 18+ esteja instalado: node --version
Teste manualmente: npx sceneview-mcp — deve iniciar sem erros
Reinicie seu cliente de IA após alterar a configuração do MCP

"Comando npx não encontrado"

Instale o Node.js de nodejs.org (LTS recomendado). npm e npx estão incluídos.

O servidor inicia, mas as ferramentas não estão disponíveis

Claude Desktop: verifique o ícone do MCP na barra de entrada — deve mostrar "sceneview" como conectado
Cursor: verifique Configurações > MCP para status verde
Reinicie o cliente de IA para forçar uma reconexão

Problemas de firewall ou proxy

As únicas chamadas de rede são para a API do GitHub (para issues conhecidas), Sketchfab (quando SKETCHFAB_API_KEY está definido), Tripo AI (quando TRIPO_API_KEY está definido e generate_3d_model é chamado) e o endpoint de telemetria anônima (desligado com SCENEVIEW_TELEMETRY=0). Todo o resto funciona offline.

{
  "mcpServers": {
    "sceneview": {
      "command": "npx",
      "args": ["-y", "sceneview-mcp"],
      "env": {
        "HTTPS_PROXY": "http://proxy.example.com:8080"
      }
    }
  }
}

Patrocinador

Se o sceneview-mcp economiza seu tempo, considere doar no Open Collective, ou GitHub Sponsors se preferir. Construir isso é um trabalho de amor de um único desenvolvedor; toda ferramenta é gratuita com ou sem doação.

Telemetria anônima

Habilitada por padrão (nome/versão do cliente MCP e nomes de ferramentas — sem dados pessoais, sem conteúdo de prompts). Desative com SCENEVIEW_TELEMETRY=0. Veja PRIVACY.md para a forma completa do payload.

Desenvolvimento

cd mcp
npm install
npm run prepare  # Copy llms.txt + build TypeScript
npm test         # vitest suite
npm run lint     # Biome (repo-root biome.json) — lint + format + import assists
npm run lint:fix # same, applying the safe fixes
npm run dev      # Start with tsx (hot reload)

Estrutura do projeto

mcp/
  src/
    index.ts             # CLI entry point — stdio, or Streamable HTTP with --http
    server.ts            # The MCP Server (resources + tools), shared by both transports
    http.ts              # Streamable HTTP entrypoint (/mcp, /health, OpenAI challenge)
    widgets.ts           # MCP Apps widget: ui://widget/3d-viewer.html (SceneView.js + Filament.js)
    tools/handler.ts     # Tool dispatcher
    surfaces.ts          # Which tools the anonymous remote surface serves
    samples.ts           # 38 compilable code samples (Kotlin + Swift)
    validator.ts         # Code validator (30+ rules)
    node-reference.ts    # Node type parser
    guides.ts            # Best practices, AR setup, roadmap, troubleshooting
    migration.ts         # v2 -> v3 -> v4 migration guide
    preview.ts           # 3D preview URL generator
    artifact.ts          # HTML artifact generator (model-viewer, charts, product 360)
    issues.ts            # GitHub issues fetcher (cached)
    search-models.ts     # Sketchfab BYOK search
    generate-model.ts    # Tripo BYOK text/image -> GLB generation
    analyze-project.ts   # Local project scanner
  llms.txt               # Bundled API reference (copied from repo root)

Contribuindo

Faça um fork do repositório
Crie um branch de funcionalidade
Adicione testes para novas ferramentas ou regras
Execute npm test — todos os testes devem passar
Envie um pull request

Veja CONTRIBUTING.md para o guia completo.

Legal

LICENSE — Licença MIT
TERMS.md — Termos de Serviço
PRIVACY.md — Política de Privacidade