sceneview-mcp

sceneview-mcp

Give any AI assistant expert-level knowledge of 3D and AR development.

The official Model Context Protocol server for SceneView — the cross-platform 3D & AR SDK for Android (Jetpack Compose + Filament), iOS / macOS / visionOS (SwiftUI + RealityKit), and Web (Filament.js + WebXR).

Connect it to Claude, Cursor, Windsurf, or any MCP client. Your AI assistant gets specialized tools, compilable code samples, the full API reference, and a code validator — so it writes correct, working 3D/AR code on the first try.

Disclaimer: Generated code is provided "as is" without warranty. Always review before production use. See TERMS.md and PRIVACY.md.

Quick start

One command — no install required:

npx sceneview-mcp

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

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

Restart Claude Desktop after saving.

Claude Code

Two options.

Recommended — install the SceneView Claude Code plugin to get this MCP server plus 11 namespaced contributor commands and cross-platform reminder hooks in one shot:

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

Or — just the MCP server (lighter, no commands or hooks):

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

Cursor

Open Settings > MCP, add a new server named sceneview with command npx -y sceneview-mcp. Or add to .cursor/mcp.json:

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

Windsurf / Other MCP clients

Same JSON config as above. The server communicates via stdio using the standard MCP protocol.

What you get

Every developer tool is free: setup guides for every platform, code samples, the API reference, the migration tooling, the validator, model search, and the project analyzer.

Free tools

Setup & integration

Tool	What it does
get_setup	Gradle + manifest setup for Android 3D or AR
get_ios_setup	SPM dependency, Info.plist, SwiftUI for iOS / macOS / visionOS
get_web_setup	Kotlin/JS + Filament.js (WASM) for browser-based 3D
get_ar_setup	Permissions, session options, plane detection, image tracking
get_platform_setup	Unified setup guide for any platform (Android, iOS, Web, Flutter, RN, Desktop, TV)

Code generation & migration

Tool	What it does
get_sample	Returns a complete, compilable code sample for any of 33 scenarios (Kotlin or Swift)
list_samples	Browse all samples, filter by tag (ar, 3d, ios, animation, geometry, ...)
validate_code	Checks generated code against 30+ rules — including symbol existence against the real public API, with did-you-mean suggestions — before presenting it to the user
migrate_code	Automatically migrates SceneView 2.x / 3.x code with detailed changelog
get_migration_guide	Every breaking change with before/after code

API reference

Tool	What it does
get_node_reference	Full API reference for any of 44+ node types — exact signatures, defaults, examples
list_platforms	Supported platforms with their status, renderer, and framework
get_platform_roadmap	Multi-platform status and timeline

Guides

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

Discovery & analysis

Tool	What it does
search_models	Searches Sketchfab for free 3D models (BYOK — set SKETCHFAB_API_KEY)
generate_3d_model	Generates a brand-new GLB from a text prompt or image via Tripo AI (BYOK — set TRIPO_API_KEY)
analyze_project	Scans a local SceneView project on disk — detects platform, extracts version, flags outdated deps and known anti-patterns
search_android_docs	Searches Google's stock Android docs knowledge base (needs the android CLI on PATH)
fetch_android_doc	Fetches a full Android docs entry by its kb://... URI (needs the android CLI on PATH)

2 resources

Resource URI	What it provides
sceneview://api	Complete SceneView 4.0.x API reference (the full llms.txt)
sceneview://known-issues	Live open issues from GitHub (cached 10 min)

search_models — find real 3D assets from the AI

Generated SceneView code is only useful if it points at an asset that actually exists. search_models queries Sketchfab's public search API and returns a shortlist with names, authors, licenses, thumbnails, triangle counts, and viewer/embed URLs that the assistant can drop straight into rememberModelInstance(modelLoader, ...) or embed as a live preview.

Bring your own key (BYOK). SceneView never proxies the request — you keep the rate limit and the cost stays at zero. To set it up:

• Create a free account at sketchfab.com/register
• Copy your API token from sketchfab.com/settings/password
• Set SKETCHFAB_API_KEY in your MCP client config:

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

Call it like search_models({ query: "red sports car", category: "cars-vehicles", maxResults: 6 }). If the key is missing, the tool returns a clear message explaining how to get one instead of failing silently.

generate_3d_model — create brand-new 3D assets from the AI

When no existing model fits, generate_3d_model closes the other half of the asset loop: it generates a fresh GLB from a text prompt (text→3D) or a source image (image→3D) via the Tripo AI API, then returns a direct GLB download URL plus license/attribution metadata — ready for rememberModelInstance(modelLoader, ...) and AR placement.

Two quality tiers:

quality	Tripo model	Topology	Latency	Approx. cost (July 2026)
"fast" (default)	P1 (P1-20260311)	low-poly, AR-ready	~25–30 s	~$0.10–0.25 of your credits
"hd"	H3.1 (v3.1-20260211)	quad mesh, detailed geometry + textures	up to ~100 s	~$0.41 of your credits

Bring your own key (BYOK). Exactly like search_models: SceneView never proxies the request or holds your key — generations are billed to your Tripo account. To set it up:

• Create an API key at platform.tripo3d.ai/api-keys (new accounts get free trial credits)
• Set TRIPO_API_KEY in your MCP client config:

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

Call it like generate_3d_model({ prompt: "a low-poly cactus in a striped pot" }) or generate_3d_model({ imageUrl: "https://example.com/chair.jpg", quality: "hd" }). Provide exactly one of prompt / imageUrl.

⚠️ The GLB download URL expires ~5 minutes after generation — download the file immediately and self-host it (e.g. copy it into your app's assets/models/). The tool result repeats this warning. Missing key, task failures, rate limits, and poll timeouts (2 min fast / 4 min hd cap) all return clear, actionable messages instead of hanging or crashing.

analyze_project — local project scan

Because the MCP server runs on the user's machine, analyze_project can read their project files directly. Given a path (default: process.cwd()), it:

• Detects the project type by looking for build.gradle(.kts) with io.github.sceneview:sceneview (Android), Package.swift with SceneViewSwift (iOS), or package.json with sceneview-web (Web).
• Extracts the SceneView dependency version and compares it against the latest release known to this MCP build, flagging outdated projects.
• Walks up to 30 source files (.kt, .kts, .swift, .js, .ts) and up to 500 KB total, scanning for well-known anti-patterns: Filament/ModelLoader calls inside background coroutines, the LightNode(...) { ... } trailing-lambda bug, deprecated 2.x APIs (ArSceneView, TransformableNode, PlacementNode, ViewRenderable, loadModelAsync), and com.google.ar.sceneform.* imports.
• Returns a structured { projectType, sceneViewVersion, latestVersion, isOutdated, warnings, suggestions } report, plus a Markdown summary.

The tool is read-only, never writes to disk, and gracefully handles missing directories. Use it when the user asks "is my project up to date?" or as a quick sanity check before generating new code for an existing codebase.

Examples

"Build me an AR app"

The assistant calls get_ar_setup + get_sample("ar-model-viewer") and returns a complete, compilable Kotlin composable with all imports, Gradle dependencies, and manifest entries. Ready to paste into Android Studio.

"Create a 3D model viewer for iOS"

The assistant calls get_ios_setup("3d") + get_sample("ios-model-viewer") and returns Swift code with the SPM dependency, Info.plist entries, and a working SwiftUI view.

"What parameters does LightNode accept?"

The assistant calls get_node_reference("LightNode") and returns the exact function signature, parameter types, defaults, and a usage example — including the critical detail that apply is a named parameter, not a trailing lambda.

"Validate this code before I use it"

The assistant calls validate_code with the generated snippet and checks it against 30+ rules: symbol existence against the real public API (unknown imports, made-up node types, nonexistent loader methods — each with did-you-mean suggestions), threading violations, null safety, API correctness, lifecycle issues, deprecated APIs. Problems are flagged with explanations before the code reaches the user.

Why this exists

Without this MCP server, AI assistants regularly:

• Recommend deprecated Sceneform (abandoned 2021) instead of SceneView
• Generate imperative View-based code instead of Jetpack Compose
• Use wrong API signatures or outdated parameter names
• Miss the LightNode named-parameter gotcha (apply = not trailing lambda)
• Forget null-checks on rememberModelInstance (it returns null while loading)
• Have no knowledge of SceneView's iOS/Swift API at all

With this MCP server, AI assistants:

• Always use the current SceneView 4.0.x API surface
• Generate correct Compose-native 3D/AR code for Android
• Generate correct SwiftUI-native code for iOS/macOS/visionOS
• Know about all 44+ node types and their exact parameters
• Validate code against 30+ rules before presenting it
• Provide working, tested sample code for 33 scenarios

Quality

The MCP server is tested with 1,898 unit tests across 81 test suites covering:

• Every tool response (correct output, error handling, edge cases)
• All 33 code samples (compilable structure, correct imports, no deprecated APIs)
• Code validator rules (true positives and false-positive resistance)
• Node reference parsing (all node types extracted correctly from llms.txt)
• Resource responses (API reference, GitHub issues integration)

 Test Files  81 passed (81)
      Tests  1898 passed (1898)

All tools work fully offline except sceneview://known-issues (GitHub API, cached 10 min), search_models (Sketchfab, BYOK), and generate_3d_model (Tripo AI, BYOK).

Troubleshooting

"MCP server not found" or connection errors

• Ensure Node.js 18+ is installed: node --version
• Test manually: npx sceneview-mcp — should start without errors
• Restart your AI client after changing the MCP configuration

"npx command not found"

Install Node.js from nodejs.org (LTS recommended). npm and npx are included.

Server starts but tools are not available

• Claude Desktop: check the MCP icon in the input bar — it should show "sceneview" as connected
• Cursor: check Settings > MCP for green status
• Restart the AI client to force a reconnect

Firewall or proxy issues

The only network calls are to the GitHub API (for known issues), Sketchfab (when SKETCHFAB_API_KEY is set), and Tripo AI (when TRIPO_API_KEY is set and generate_3d_model is called). Everything else works offline.

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

Optional: vertical packages

A small set of domain-specific tools is gated behind an optional subscription. They aren't required for general 3D/AR work — only useful if you happen to be building one of these specific verticals:

• Automotive — car configurator, paint shader, parts catalog, HUD overlay, AR showroom
• Gaming — physics, particles, level editor, character viewer, inventory 3D
• Healthcare — surgical planning, dental viewer, medical imaging, anatomy, molecule viewer
• Interior — room planner, lighting design, material switcher, furniture placement, room tour

Plus 3 generation helpers: render_3d_preview, create_3d_artifact, generate_scene.

The base SDK and every developer tool listed above stay free, always.

Sponsor

If sceneview-mcp saves you time, consider sponsoring on GitHub Sponsors. Building this is a one-dev labor of love and donations keep the free tier covered.

Anonymous telemetry

Enabled by default on the free tier (MCP client name/version and tool names — no personal data, no prompt content). Opt out with SCENEVIEW_TELEMETRY=0. See PRIVACY.md for the full payload shape.

Development

cd mcp
npm install
npm run prepare  # Copy llms.txt + build TypeScript
npm test         # 1898 tests
npm run dev      # Start with tsx (hot reload)

Project structure

mcp/
  src/
    index.ts             # MCP server entry point
    tools/handler.ts     # Tool dispatcher (free + pro)
    tiers.ts             # Free vs Pro tier mapping
    samples.ts           # 33 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
    proxy.ts             # Pro-tool proxy to hosted gateway
  llms.txt               # Bundled API reference (copied from repo root)

Contributing

• Fork the repository
• Create a feature branch
• Add tests for new tools or rules
• Run npm test — all 1898+ tests must pass
• Submit a pull request

See CONTRIBUTING.md for the full guide.

Legal

• LICENSE — MIT License
• TERMS.md — Terms of Service
• PRIVACY.md — Privacy Policy