SceneView MCP

22 herramientas para desarrollo 3D y AR: genera código SceneView correcto y compilable para Android (Jetpack Compose) e iOS (SwiftUI). 858 pruebas.

GitHub

1.3k

Prueba este MCPPatrocinado

Documentación

sceneview-mcp

Dale a cualquier asistente de IA conocimiento experto en desarrollo 3D y AR.

El servidor oficial de Model Context Protocol para SceneView — el SDK 3D y AR multiplataforma para Android (Jetpack Compose + Filament), iOS / macOS / visionOS (SwiftUI + RealityKit) y Web (Filament.js + WebXR).

Conéctalo a Claude Code, Cline, Codex, Cursor, GitHub Copilot, JetBrains AI Assistant — o a cualquier otro cliente MCP — localmente a través de stdio, o de forma remota a través de Streamable HTTP en https://mcp.sceneview.dev/mcp (consulta Servidor remoto). Tu asistente de IA obtiene herramientas especializadas, ejemplos de código compilables, la referencia completa de la API, un validador de código y un visor 3D integrado — para que escriba código 3D/AR correcto y funcional al primer intento.

Aviso legal: El código generado se proporciona "tal cual", sin garantía. Revisa siempre antes de usarlo en producción. Consulta TERMS.md y PRIVACY.md.

Inicio rápido

Un solo comando — sin necesidad de instalación:

npx sceneview-mcp

Cada cliente de la lista ejecuta ese mismo servidor. Existen tres formatos de configuración en el ecosistema: mcpServers (la mayoría de los clientes), servers (VS Code) y [mcp_servers.*] (Codex TOML) — pero el comando y los argumentos son idénticos en los tres.

Cualquier cliente MCP

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

Claude Code

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

O confirma .mcp.json en la raíz del repositorio para que todo el equipo lo reciba:

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

Opcionalmente, el plugin de SceneView para Claude Code incluye este servidor con 11 comandos de contribución con espacio de nombres y recordatorios multiplataforma:

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

Claude Desktop

Configuración → Desarrollador → Editar configuración, y luego añade el bloque estándar mcpServers de arriba a ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) o %APPDATA%\Claude\claude_desktop_config.json (Windows). Reinicia después de guardar.

Cline

Icono de Servidores MCP → Configurar → Configurar servidores MCP, o ~/.cline/mcp.json:

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

Codex

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

O ~/.codex/config.toml — TOML, y la tabla es mcp_servers, no mcpServers:

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

La misma configuración sirve para Codex CLI, la extensión del IDE y la aplicación.

Cursor

Añade a .cursor/mcp.json (proyecto) o ~/.cursor/mcp.json (global) — el bloque estándar mcpServers de arriba. Cursor también acepta un enlace de instalación:

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

Gemini CLI

La raíz del repositorio incluye un gemini-extension.json, por lo que la CLI instala el servidor directamente desde GitHub — sin necesidad de pegar JSON:

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

Esto clona todo el monorepositorio — más de 2 GB de historial — porque la CLI instala una extensión clonando el repositorio que la declara, y el manifiesto de SceneView se encuentra en un repositorio que también contiene los fuentes de Android, Apple, Web, Flutter y React Native. Si quieres el servidor y no el clon, pega el bloque estándar mcpServers en ~/.gemini/settings.json; es el mismo comando, npx -y sceneview-mcp, y solo requiere descargar el paquete npm.

En cualquier caso, npx resuelve sceneview-mcp a la última versión publicada en npm, que no es necesariamente la versión que declara este manifiesto — el version del manifiesto describe la extensión, y el servidor que lanza se actualiza al ritmo de npm.

La extensión no declara nada más que el servidor: npx -y sceneview-mcp a través de stdio, sin archivo de contexto y sin exclusiones de herramientas, por lo que añade las herramientas de SceneView a una sesión y no cambia nada más de ella.

Gemini en Android Studio

La integración MCP de Android Studio no admite stdio — se conecta solo por HTTP, así que apúntalo al endpoint alojado. Configuración → Herramientas → IA → Servidores MCP:

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

GitHub Copilot

En VS Code, .vscode/mcp.json — ten en cuenta la clave servers, no mcpServers:

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

VS Code también acepta un enlace de instalación:

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

En Copilot CLI:

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

JetBrains AI Assistant / Junie

Configuración → Herramientas → AI Assistant → Model Context Protocol (MCP) → Añadir, y luego pega el bloque estándar mcpServers de arriba.

MCP Bundle (`.mcpb`)

mcp/manifest.json describe este servidor en el formato MCP Bundle (especificación 0.3), para aplicaciones de escritorio que instalan un servidor local desde un bundle en lugar de una línea de comandos. Ejecuta el dist/index.js compilado con el Node del host — el host proporciona el runtime y nada más, por lo que el bundle tiene que incluir su propio node_modules. Comprimir este directorio después de npm run build solo produce un bundle que falla al iniciarse con 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 no es opcional: el script prepare de este paquete termina en tsc, y el mismo comando que omite las dependencias de desarrollo omite TypeScript, por lo que sin él npm ejecuta prepare, no encuentra tsc y sale con el código 127. Reinstala con un npm ci simple después para recuperar el árbol de desarrollo.

El manifiesto no se publica como artefacto de .mcpb por CI: es el descriptor, y empaquetarlo sigue siendo un paso manual para quien necesite un bundle. mcp/src/packaging.test.ts mantiene su nombre, versión, licencia, punto de entrada y rango de Node iguales a los de package.json — y hace lo mismo para server.json y el gemini-extension.json raíz — porque nada más notaría que se desincronizan.

Uso como conector remoto

Sin instalación, nada que ejecutar: SceneView está alojado como servidor MCP remoto en

https://mcp.sceneview.dev/mcp

Cualquier cliente que acepte una URL MCP de Streamable HTTP puede usarlo. En claude.ai, eso es Configuración → Conectores → Añadir conector personalizado.

Sin autenticación y de solo lectura. No hay inicio de sesión, ni clave de API, ni cuenta: cada herramienta es una función pura de la propia documentación, ejemplos y superficie de API del SDK, por lo que no hay nada que autenticar ni nada tuyo almacenado. Todas las herramientas están anotadas como readOnlyHint excepto generate_3d_model, que llama a un servicio de generación externo y por lo tanto está marcada como de mundo abierto en lugar de solo lectura.

¿Lo prefieres local? npx -y sceneview-mcp ejecuta exactamente el mismo servidor a través de stdio. La ruta local es la que lee tu proyecto desde el disco (analyze_project) y la que acepta tus propios SKETCHFAB_API_KEY / TRIPO_API_KEY; el conector alojado, al ser compartido y anónimo, no puede.

Servidor remoto (Streamable HTTP)

Algunos hosts no pueden lanzar un proceso local: necesitan el transporte Streamable HTTP de MCP en una URL pública. El mismo paquete lo sirve:

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

Ruta	Qué hace
`POST /mcp`	MCP JSON-RPC (Streamable HTTP, sin estado — sin sesiones, seguro detrás de cualquier balanceador de carga)
`GET` / `DELETE /mcp`	`405` (sin flujo SSE independiente, sin sesión que eliminar)
`GET /health`	`{"status":"ok","version":"4.x.y"}`
`GET /.well-known/openai-apps-challenge`	Verificación de dominio de OpenAI — devuelve `OPENAI_APPS_CHALLENGE_TOKEN` como `text/plain`, `404` cuando no está configurado
cualquier otra cosa	`404`

Configuración: PORT (por defecto 3333), HOST (por defecto 127.0.0.1 — establece HOST=0.0.0.0 para exponerlo y pon HTTPS delante), OPENAI_APPS_CHALLENGE_TOKEN (el valor que OpenAI te da cuando envías el dominio). CORS permite cualquier origen. Los controles habituales de SKETCHFAB_API_KEY / TRIPO_API_KEY / SCENEVIEW_TELEMETRY=0 se aplican.

Todo es gratuito, pero no todo es remoto. Tres herramientas de generación (render_3d_preview, create_3d_artifact, generate_scene) necesitan tus propias credenciales de terceros, que un endpoint anónimo compartido no puede contener, por lo que la superficie remota las omite y rechaza esos nombres en el momento de la llamada con un mensaje claro de isError que apunta a la ruta local npx sceneview-mcp. stdio lista y ejecuta las 32.

Visor 3D integrado. view_3d_model devuelve structuredContent más _meta.ui.resourceUri = ui://widget/3d-viewer.html; el widget (SceneView.js + Filament.js, servido por resources/read con el tipo MIME text/html;profile=mcp-app y su _meta.ui.csp) renderiza el modelo integrado en ChatGPT y en cualquier host de MCP Apps.

Prueba de humo con curl (el encabezado Accept es obligatorio según la especificación):

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"}}}

Apunta el conector de ChatGPT / la herramienta mcp de OpenAI a https://<your-host>/mcp.

Ya está alojado. No tienes que ejecutarlo tú mismo para obtener una URL pública: el mismo código está desplegado en https://mcp.sceneview.dev/mcp (GET /health responde {"status":"ok"}), que es a lo que apunta el conector remoto de arriba. Alójalo tú mismo cuando quieras tus propias claves, tus propios límites de velocidad, o analyze_project contra un checkout local.

Lo que obtienes

Cada herramienta es gratuita y no hay clave de API. Las tres herramientas de generación que hablan con un servicio de terceros usan tus credenciales; todo lo demás funciona en cuanto el servidor arranca.

Empieza aquí

Seis herramientas cubren la mayor parte de lo que los asistentes hacen realmente con SceneView. Si no lees nada más:

Herramienta	Qué hace	Pregunta a tu asistente
`validate_code`	Verifica la compilación del Kotlin o Swift generado contra la API pública real — existencia de símbolos, más de 30 reglas, sugerencias de "quisiste decir" — antes de que llegue a ti	"Comprueba que este código de SceneView realmente compila"
`get_node_reference`	La firma exacta, los valores predeterminados y el ejemplo de cualquiera de los más de 48 tipos de nodo, en lugar de uno inventado	"¿Cuáles son los parámetros de ModelNode?"
`list_samples`	Explora 38 escenarios por etiqueta (`ar`, `3d`, `ios`, `animation`, `geometry`, …)	"¿Qué ejemplos de SceneView involucran planos AR?"
`get_sample`	Devuelve uno de ellos completo y compilable, en Kotlin o Swift	"Dame el ejemplo de colocación de planos AR en Kotlin"
`get_setup`	Configuración de Gradle y manifiesto para Android 3D o AR	"Configura SceneView en mi aplicación Android"
`get_ar_setup`	Permisos, opciones de sesión, detección de planos, seguimiento de imágenes	"Añade detección de planos ARCore a esta pantalla"

Referencia completa de herramientas

Configuración e integración

Herramienta	Qué hace
`get_setup`	Configuración de Gradle + manifiesto para Android 3D o AR
`get_ios_setup`	Dependencia SPM, Info.plist, SwiftUI para iOS / macOS / visionOS
`get_web_setup`	Kotlin/JS + Filament.js (WASM) para 3D en navegador
`get_ar_setup`	Permisos, opciones de sesión, detección de planos, seguimiento de imágenes
`get_platform_setup`	Guía de configuración unificada para cualquier plataforma (Android, iOS, Web, Flutter, RN, Desktop, TV)

Generación y migración de código

Herramienta	Qué hace
`get_sample`	Devuelve un ejemplo de código completo y compilable para cualquiera de los 38 escenarios (Kotlin o Swift)
`list_samples`	Explora todos los ejemplos, filtra por etiqueta (`ar`, `3d`, `ios`, `animation`, `geometry`, ...)
`validate_code`	Verifica el código generado contra más de 30 reglas — incluida la existencia de símbolos contra la API pública real, con sugerencias de "quisiste decir" — antes de presentarlo al usuario
`migrate_code`	Migra automáticamente código de SceneView 2.x / 3.x con registro de cambios detallado
`get_migration_guide`	Cada cambio incompatible con código antes/después

Referencia de API

Herramienta	Qué hace
`get_node_reference`	Referencia completa de la API para cualquiera de los más de 48 tipos de nodo — firmas exactas, valores predeterminados, ejemplos
`list_platforms`	Plataformas compatibles con su estado, renderizador y framework
`get_platform_roadmap`	Estado y cronología multiplataforma

Guías

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

Descubrimiento y análisis

Herramienta	Qué hace
`search_models`	Busca modelos 3D gratuitos en Sketchfab (BYOK — configure `SKETCHFAB_API_KEY`)
`generate_3d_model`	Genera un GLB completamente nuevo a partir de un prompt de texto o una imagen mediante Tripo AI (BYOK — configure `TRIPO_API_KEY`)
`analyze_project`	Escanea un proyecto SceneView local en disco — detecta la plataforma, extrae la versión, marca dependencias obsoletas y anti-patrones conocidos
`search_android_docs`	Busca en la base de conocimiento de documentación estándar de Android de Google (requiere el CLI `android` en PATH)
`fetch_android_doc`	Obtiene una entrada completa de documentación de Android por su URI `kb://...` (requiere el CLI `android` en PATH)

Visor 3D integrado (widget de MCP Apps)

Herramienta	Qué hace
`view_3d_model`	Renderiza una URL pública de GLB / glTF en un visor interactivo SceneView.js + Filament.js integrado en ChatGPT y cualquier host de MCP Apps (órbita, auto-rotación). Para un modelo https añade una acción "Abrir en AR en tu teléfono" (un enlace `ar.sceneview.dev/open` a la app 3D AR Model Viewer, con código QR en escritorio). Devuelve `structuredContent` + `_meta.ui.resourceUri`

5 recursos

URI del recurso	Qué proporciona
`sceneview://api`	Referencia completa de la API SceneView 4.x (el `llms.txt` completo)
`sceneview://known-issues`	Problemas abiertos en vivo desde GitHub (caché de 10 min)
`examples://demo-with-settings`	Patrón DemoScaffold v2 — escena a pantalla completa + hoja inferior Material 3
`examples://sketchfab-streaming`	Transmisión de modelos Sketchfab CC-BY en una demo en lugar de empaquetar GLBs
`ui://widget/3d-viewer.html`	El widget de visor 3D (`text/html;profile=mcp-app`) en el que `view_3d_model` renderiza

`search_models` — encuentra activos 3D reales desde la IA

El código SceneView generado solo es útil si apunta a un activo que realmente existe. search_models consulta la API pública de búsqueda de Sketchfab y devuelve una lista corta con nombres, autores, licencias, miniaturas, recuentos de triángulos y URLs de visor/incrustación que el asistente puede insertar directamente en rememberModelInstance(modelLoader, ...) o incrustar como vista previa en vivo.

Trae tu propia clave (BYOK). SceneView nunca hace de proxy en la solicitud — tú mantienes el límite de tasa y el costo se mantiene en cero. Para configurarlo:

Crea una cuenta gratuita en sketchfab.com/register
Copia tu token de API desde sketchfab.com/settings/password
Configura SKETCHFAB_API_KEY en la configuración de tu cliente MCP:

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

Llámalo como search_models({ query: "red sports car", category: "cars-vehicles", maxResults: 6 }). Si falta la clave, la herramienta devuelve un mensaje claro explicando cómo obtener una en lugar de fallar silenciosamente.

`generate_3d_model` — crea activos 3D completamente nuevos desde la IA

Cuando ningún modelo existente encaja, generate_3d_model cierra la otra mitad del ciclo de activos: genera un GLB nuevo a partir de un prompt de texto (texto→3D) o una imagen fuente (imagen→3D) mediante la API de Tripo AI, y luego devuelve una URL de descarga directa del GLB más metadatos de licencia/atribución — listo para rememberModelInstance(modelLoader, ...) y colocación en AR.

Dos niveles de calidad:

`quality`	Modelo Tripo	Topología	Latencia	Costo aproximado (julio 2026)
`"fast"` (predeterminado)	P1 (`P1-20260311`)	low-poly, listo para AR	~25–30 s	~$0.10–0.25 de tus créditos
`"hd"`	H3.1 (`v3.1-20260211`)	malla quad, geometría detallada + texturas	hasta ~100 s	~$0.41 de tus créditos

Trae tu propia clave (BYOK). Exactamente como search_models: SceneView nunca hace de proxy en la solicitud ni guarda tu clave — las generaciones se facturan a tu cuenta de Tripo. Para configurarlo:

Crea una clave de API en platform.tripo3d.ai/api-keys (las cuentas nuevas reciben créditos de prueba gratuitos)
Configura TRIPO_API_KEY en la configuración de tu cliente MCP:

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

Llámalo como generate_3d_model({ prompt: "a low-poly cactus in a striped pot" }) o generate_3d_model({ imageUrl: "https://example.com/chair.jpg", quality: "hd" }). Proporciona exactamente uno de prompt / imageUrl.

⚠️ La URL de descarga del GLB expira ~5 minutos después de la generación — descarga el archivo inmediatamente y alójalo tú mismo (por ejemplo, cópialo en el assets/models/ de tu app). El resultado de la herramienta repite esta advertencia. Clave faltante, fallos de tarea, límites de tasa y tiempos de espera de sondeo (2 min rápido / 4 min límite HD) devuelven mensajes claros y accionables en lugar de colgarse o fallar.

`analyze_project` — escaneo de proyecto local

Debido a que el servidor MCP se ejecuta en la máquina del usuario, analyze_project puede leer sus archivos de proyecto directamente. Dado un path (predeterminado: process.cwd()), este:

Detecta el tipo de proyecto buscando build.gradle(.kts) con io.github.sceneview:sceneview (Android), Package.swift con SceneViewSwift (iOS), o package.json con sceneview-web (Web).
Extrae la versión de la dependencia SceneView y la compara con la última versión conocida por esta compilación de MCP, marcando proyectos desactualizados.
Recorre hasta 30 archivos fuente (.kt, .kts, .swift, .js, .ts) y hasta 500 KB en total, escaneando anti-patrones conocidos: llamadas a Filament/ModelLoader dentro de corrutinas en segundo plano, el error de lambda final LightNode(...) { ... }, APIs 2.x obsoletas (ArSceneView, TransformableNode, PlacementNode, ViewRenderable, loadModelAsync) e importaciones com.google.ar.sceneform.*.
Devuelve un informe estructurado { projectType, sceneViewVersion, latestVersion, isOutdated, warnings, suggestions }, más un resumen en Markdown.

La herramienta es de solo lectura, nunca escribe en disco y maneja con elegancia directorios faltantes. Úsala cuando el usuario pregunte "¿está mi proyecto actualizado?" o como verificación rápida antes de generar código nuevo para un código base existente.

Ejemplos

"Créame una app de AR"

El asistente llama a get_ar_setup + get_sample("ar-model-viewer") y devuelve un composable Kotlin completo y compilable con todas las importaciones, dependencias de Gradle y entradas de manifiesto. Listo para pegar en Android Studio.

"Cree un visor de modelos 3D para iOS"

El asistente llama a get_ios_setup("3d") + get_sample("ios-model-viewer") y devuelve código Swift con la dependencia SPM, entradas de Info.plist y una vista SwiftUI funcional.

"¿Qué parámetros acepta LightNode?"

El asistente llama a get_node_reference("LightNode") y devuelve la firma exacta de la función, los tipos de parámetros, los valores predeterminados y un ejemplo de uso — incluido el detalle crítico de que apply es un parámetro nombrado, no una lambda final.

"Valide este código antes de usarlo"

El asistente llama a validate_code con el fragmento generado y lo verifica contra más de 30 reglas: existencia de símbolos contra la API pública real (importaciones desconocidas, tipos de nodo inventados, métodos de cargador inexistentes — cada uno con sugerencias de "quisiste decir"), violaciones de hilos, seguridad de nulos, corrección de API, problemas de ciclo de vida, APIs obsoletas. Los problemas se marcan con explicaciones antes de que el código llegue al usuario.

Por qué existe esto

Sin este servidor MCP, los asistentes de IA regularmente:

Recomiendan Sceneform obsoleto (abandonado en 2021) en lugar de SceneView
Generan código imperativo basado en View en lugar de Jetpack Compose
Usan firmas de API incorrectas o nombres de parámetros desactualizados
Pasan por alto el detalle del parámetro nombrado LightNode (apply = no es lambda final)
Olvidan verificaciones de nulos en rememberModelInstance (devuelve null mientras carga)
No tienen ningún conocimiento de la API iOS/Swift de SceneView

Con este servidor MCP, los asistentes de IA:

Siempre usan la superficie de API actual de SceneView 4.x
Generan código 3D/AR nativo de Compose correcto para Android
Generan código nativo de SwiftUI correcto para iOS/macOS/visionOS
Conocen los más de 48 tipos de nodo y sus parámetros exactos
Validan código contra más de 30 reglas antes de presentarlo
Proporcionan código de muestra funcional y probado para 38 escenarios

Calidad

El servidor MCP se prueba con 2,015 pruebas unitarias en 91 archivos de prueba que cubren:

Cada respuesta de herramienta (salida correcta, manejo de errores, casos límite)
Los 38 ejemplos de código (estructura compilable, importaciones correctas, sin APIs obsoletas)
Reglas del validador de código (verdaderos positivos y resistencia a falsos positivos)
Análisis de referencia de nodos (todos los tipos de nodo extraídos correctamente de llms.txt)
Respuestas de recursos (referencia de API, integración de problemas de GitHub, el widget de visor 3D)
La superficie HTTP Streamable de extremo a extremo (inicialización, herramientas gratuitas/solo lista, recurso de widget, salud, desafío OpenAI)

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

Todas las herramientas funcionan completamente sin conexión excepto sceneview://known-issues (API de GitHub, caché de 10 min), search_models (Sketchfab, BYOK) y generate_3d_model (Tripo AI, BYOK). La telemetría anónima también realiza una llamada de red a menos que SCENEVIEW_TELEMETRY=0 (ver abajo).

Solución de problemas

"Servidor MCP no encontrado" o errores de conexión

Asegúrate de que Node.js 18+ esté instalado: node --version
Prueba manualmente: npx sceneview-mcp — debería iniciar sin errores
Reinicia tu cliente de IA después de cambiar la configuración de MCP

"Comando npx no encontrado"

Instala Node.js desde nodejs.org (se recomienda LTS). npm y npx están incluidos.

El servidor inicia pero las herramientas no están disponibles

Claude Desktop: verifica el ícono de MCP en la barra de entrada — debería mostrar "sceneview" como conectado
Cursor: verifica Configuración > MCP para estado verde
Reinicia el cliente de IA para forzar una reconexión

Problemas de firewall o proxy

Las únicas llamadas de red son a la API de GitHub (para problemas conocidos), Sketchfab (cuando SKETCHFAB_API_KEY está configurado), Tripo AI (cuando TRIPO_API_KEY está configurado y se llama a generate_3d_model) y el endpoint de telemetría anónima (desactivado con SCENEVIEW_TELEMETRY=0). Todo lo demás funciona sin conexión.

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

Patrocinador

Si sceneview-mcp te ahorra tiempo, considera donar en Open Collective, o GitHub Sponsors si lo prefieres. Construir esto es un trabajo de amor de un solo desarrollador; cada herramienta es gratuita con o sin donación.

Telemetría anónima

Habilitada por defecto (nombre/versión del cliente MCP y nombres de herramientas — sin datos personales, sin contenido de prompts). Desactívala con SCENEVIEW_TELEMETRY=0. Consulta PRIVACY.md para la forma completa del payload.

Desarrollo

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)

Estructura del proyecto

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)

Contribuciones

Haz un fork del repositorio
Crea una rama de características
Añade pruebas para nuevas herramientas o reglas
Ejecuta npm test — todas las pruebas deben pasar
Envía una solicitud de extracción

Consulta CONTRIBUTING.md para la guía completa.

Legal

LICENSE — Licencia MIT
TERMS.md — Términos de Servicio
PRIVACY.md — Política de Privacidad