The ViroReact MCP Server (https://mcp.reactvision.xyz/viro) is ReactVision's official Model Context Protocol server. It plugs live, accurate ViroReact knowledge straight into any MCP-capable coding agent — Claude, Claude Code, Codex, Cursor, Windsurf, and others — so the agent writes correct cross-platform XR code from current data instead of working from stale training. Under the hood it indexes the @reactvision/react-viro framework, its companion packages (@reactvision/react-viro-onnx behind ViroObjectDetector, and @reactvision/react-viro-face-tracking), the framework docs, and the real-world showcase AR examples, then exposes that knowledge through a set of purpose-built tools: component and prop schemas, curated platform and feature catalogues, scene generation and conversion, static validation and diagnostics, AI asset generation, an 8th Wall migration path, and a set of cloud tools that render scenes and code against real recorded environments. It is free to use with a Studio account (authenticate and pick the Team you want usage tracked against); paid Studio plans get higher usage limits, and the tools that generate assets or run against a recorded environment draw on the platform's AI credits.

The tools below are grouped by theme. Everything is free with a Studio account except the asset-generation tools and the cloud rendering tools, where the tier and credit cost are called out per tool.

Getting oriented and codebase intelligence

High-level entry points and raw navigation over the indexed ViroReact codebase and docs.

Tool	Description
`reactviro_get_overview`	High-level architecture report: which packages are indexed, which docs are available, and which tools to use to drill in. The place to start when exploring the MCP for the first time.
`reactviro_get_tree`	Returns an ASCII directory tree of one package or all packages.
`reactviro_list_files`	Lists files in the codebase, filterable by package, language, or path, with pagination.
`reactviro_get_file`	Returns the full source of any file in the project.
`reactviro_search`	Full-text search across the whole corpus (FTS5 with a regex fallback).
`reactviro_find_symbol`	Locates a symbol (function, class, type, interface, const, or component) across the packages.
`reactviro_stats`	File counts and sizes broken down by package and language, plus the indexed-at metadata.
`reactviro_get_docs`	Returns the indexed framework documentation (README, CHANGELOG, SHADER_REFERENCE, QUEST_SETUP, VISIONOS_SETUP, VPS_LITE, and more). Pass `list=true` to see everything available.
`reactviro_changelog_since`	Parses the indexed framework CHANGELOG and returns every entry from a given version onward. Useful for "what changed since I last upgraded" and migration prep.

Component API reference

The source of truth for what components exist and what they accept. Use these before generating or rendering a scene.

Tool	Description
`reactviro_list_components`	Lists all public ViroReact components, grouped by semantic category (AR, Geometry, Lighting, Materials, Animation, Effects, Portal, Media, Audio, UI, Navigation, Camera, Input, Environment, Transform, Studio, Panoramic / 360, 3D Objects, Other).
`reactviro_list_categories`	Returns the catalogue of component categories with counts.
`reactviro_get_component`	Returns the full TypeScript source of a component.
`reactviro_get_component_props`	Returns the AST-extracted props schema for a component: name, type, optionality, JSDoc description, and `@since` tag.
`reactviro_get_component_events`	Returns the event-handler props for a component (those following the `onX` naming pattern).
`reactviro_list_props`	Inverse lookup: given a prop name or pattern, returns every component that declares it.
`reactviro_list_event_handlers`	Aggregates every `on...` event handler exposed across ViroReact components.

Reference catalogues

Curated lookups for the values that are easy to forget and hard to guess.

Tool	Description
`reactviro_get_platform_matrix`	The curated platform-support matrix for ViroReact features across iOS (ARKit), Android (ARCore), Meta Quest (OpenXR), and visionOS.
`reactviro_get_shader_uniforms`	Catalogue of `shaderModifiers` entry points (Geometric, Vertex, Surface, LightingModel, Fragment), the pipeline stage each hooks into, and the uniforms available at each stage.
`reactviro_list_lighting_models`	The `lightingModel` options for `ViroMaterials.createMaterials`: PBR, Blinn, and the rest.
`reactviro_list_animation_easings`	The easing curves accepted by `ViroAnimations.registerAnimations`.
`reactviro_list_physics_body_types`	The `physicsBody.type` options: Static, Dynamic, Kinematic.

Examples

Real scenes from the showcase repo, for reference and pattern-matching.

Tool	Description
`reactviro_list_examples`	Lists the real-world AR scene examples from the `@reactvision/showcase` repo (plane detection, custom shaders, AR portal, particle effects, depth-mesh collision, and more).
`reactviro_get_example`	Returns the full TypeScript/TSX source of a given example scene.
`reactviro_examples_using`	Given a component name, finds the example scenes that use it.

Scene generation and conversion

Produce new scenes, and move scenes between ReactViro TSX and the Studio scene format.

Tool	Description
`reactviro_generate_scene`	Generates a ready-to-use ReactViro scene template from a fixed feature list (plane detection, image tracking, 3D model, particles, portal, lighting, materials, animations, physics, custom shader, 360 image, audio, text). It does not take a free-text description — pick the closest features and adapt the returned TSX. Pass `target_platform` and the response is prefixed with compatibility warnings for that platform.
`reactviro_studio_to_tsx`	Best-effort conversion of a Studio scene response into a ReactViro TSX scene. Translates assets, materials, animations, and variables faithfully; anything it cannot map statically (Studio's visual-scripting layer, collision or proximity bindings) is listed in the warnings.
`reactviro_tsx_to_studio`	Best-effort conversion the other way: a ReactViro TSX scene into a Studio scene skeleton.

Static validation and diagnostics

Lint, inspect, and troubleshoot scenes and assets locally, without spinning up the live engine. All free.

Tool	Description
`reactviro_validate_scene`	Parses a TSX scene snippet, walks every `Viro`/`Studio` element, and validates each against the real component and prop schemas. A name-and-shape lint, not a full type checker.
`reactviro_check_platform_support`	Walks a TSX scene, identifies the platform-significant components and props, and reports unsupported combinations per platform (`ios`, `android`, `quest`, `visionos`).
`reactviro_list_assets_needed`	Scans a TSX scene snippet for static `require('...')` calls and returns the list of assets the scene depends on. Remote URLs and dynamic requires are reported separately.
`reactviro_check_performance_budget`	Fetches one or more GLB/glTF model URLs, extracts triangle count and texture footprint with a lightweight parse, and flags anything over rough per-platform budgets (`quest`, `mobile-ar`, `visionos`, `web` — Quest being the tightest). GLB and glTF-JSON with embedded buffers only; VRX/FBX/OBJ report "unsupported format" rather than a wrong number. Rough guidance, not a hard performance guarantee.
`reactviro_diagnose_error`	Matches a runtime error message, exception, or crash log against curated known-issue entries and returns likely causes and fixes.
`reactviro_find_native_bridge`	Given a JS-side prop, event, or method name, returns search hints for locating the matching native code in the reactvision-platform MCP (virocore C++, JNI bridge, iOS RCT bridges, SLAM). Does not call the native MCP itself.
`reactviro_diff_images`	Compares two PNG images pixel-by-pixel and returns the percentage of differing pixels plus a visual diff. Typically used on two `reactviro_render_scene` screenshots for before-and-after regression checks. Does no rendering itself.

Account and Studio context

Tools tied to the connected Studio Team. Both free.

Tool	Description
`reactviro_list_studio_content`	Lists the connected team's Studio projects (with their scenes and their environment library) and the team's shared assets. Call this first when rendering or generating assets: every cloud tool below takes its ids from here, so you never paste UUIDs out of Studio URLs.
`reactviro_get_usage`	Reports the team's ReactVision AI budget: credits used against the plan's limit, percentage consumed, and when it resets. Does not consume a credit, and works even when the team is over budget — so it is the tool to call when other calls are being blocked.

AI asset generation

Generate images and 3D models straight into the connected team's Studio asset library, ready to place in a scene. Available on every plan, including free, and charged to the team's monthly AI credit budget. Check the balance first with reactviro_get_usage.

Tool	Description
`reactviro_generate_image`	Generates an image with Google Gemini and saves it to the team's asset library. Synchronous — the image is finished when the call returns, though it can take up to a minute. Three tiers: `gemini-3.1-flash-lite-image` (Nano Banana 2 Lite, 15 credits) for placeholders and throwaways; `gemini-3.1-flash-image` (Nano Banana 2, 25 credits) is the default and right for almost everything; `gemini-3-pro-image` (Nano Banana Pro, 49 credits) only when the image is the centrepiece of the scene. Returns the new asset's id and file URL.
`reactviro_generate_3d_model`	Generates a GLB and saves it to the team's asset library. Asynchronous — it returns a task id and the model finishes in the background; poll `reactviro_get_3d_model_task`. Quality `quick` (Tripo, 70 credits) is the default: use it for fast iteration, simple geometry, background props and batches of secondary items. Reserve `high_quality` (Fal.ai Hunyuan3D, 125 credits) for the one or two hero assets a scene is built around. Image-to-3D is supported by passing `image_url`, which must be a ReactVision storage URL (typically one returned by `reactviro_generate_image`) and requires `high_quality` — quick mode is text-only.
`reactviro_get_3d_model_task`	Reads one 3D generation task and finalises it once the provider has finished. Poll until status is `completed` or `failed`; on completion it returns the new asset's id and file URL, plus the finished model's triangle count, texture footprint, and any platform it is over budget for.

Check the size before you place it. Generated models are not capped, and a detailed prompt can come back over a million triangles — far past what a phone or headset will load. reactviro_get_3d_model_task reports the triangle count and flags the platforms the model is too big for; reactviro_check_performance_budget breaks the same numbers down per platform. An over-budget result is common and worth acting on.

Common failures across these three: out of AI budget, out of storage, a role without permission to create assets, or an image URL from outside ReactVision storage.

Migrating from 8th Wall

A two-step path for moving an exported 8th Wall project onto ReactVision. Migration itself is free — the only gates are the connected team's storage quota (for the extracted assets) and a 200 MB cap on the export zip.

Tool	Description
`reactviro_create_8thwall_migration`	Starts the migration of an 8th Wall "Buildable Code Export" zip. This call only reserves the migration and returns a signed upload URL — PUT the zip to it, then call `reactviro_convert_8thwall_project`. The bytes go straight to storage and never through the MCP server.
`reactviro_convert_8thwall_project`	Converts the uploaded export: verifies the zip, converts it inline, uploads the extracted assets and image targets into the team's library, and returns a ViroReact project scaffold (`package.json`, `App.tsx`, `scenes/*.tsx`) plus a migration report.

What converts, and what doesn't. Niantic Studio exports (an .expanse.json scene graph) get full scene conversion. A-Frame and three.js exports get their assets and image targets extracted plus a migration report. Everything without a faithful ViroReact mapping lands in the report or as a TODO comment in the generated code — nothing is invented.

After converting, validate each scene with reactviro_validate_scene and preview it with reactviro_render_scene (format: "tsx").

Cloud rendering (environment renders)

These tools reach ReactVision's live infrastructure. Reading and listing are free, and plain screenshot rendering is free on every plan. Anything that runs against a recorded session — an "environment": a video.mp4 plus an IMU/pose sidecar, captured in StudioGo or uploaded from Studio — requires a paid Studio plan and draws down the team's AI credits. Ids for every tool here come from reactviro_list_studio_content.

Tool	Description
`reactviro_render_scene`	Free, every plan. Runs a scene through the real WASM/WebGL2 web renderer in a headless browser as a free-running page (no real-world footage) and returns PNG screenshot(s) plus console output and warnings. Takes TSX (`format: "tsx"`) or a Studio scene response (`format: "studio_json"`). Local `require('./assets/...')` calls are swapped for placeholder textures and models unless you pass `assets` with real URLs. Where the deployment has storage, frames are also saved for about an hour under `saved_frames`. For the same scene composited over a recorded session, use `reactviro_preview_in_environment`.
`reactviro_preview_in_environment`	Paid plan. Renders a scene inside one of the team's recorded AR sessions — the recording's frames as the camera background, its tracked poses as the camera — and returns an MP4 (plus a GIF with `gif`). Answers "did what I placed stay where I put it, in a real session." The output is an ephemeral preview, swept after about an hour; for a billed, persisted, Studio-visible run use `reactviro_create_environment_render`.
`reactviro_create_environment_render`	Paid plan. Queues an environment render of one Studio scene, or a set of the team's shared assets, inside an environment. Charged to the team's AI budget when queued and refunded automatically if the run fails. Give exactly one of `scene_id` or `asset_ids`.
`reactviro_get_environment_render`	Free. Reports one environment render's status, progress, what was rendered, and short-lived signed URLs for the input recording and rendered output.
`reactviro_list_environment_renders`	Free. Lists the team's environment renders, newest first, optionally narrowed to one project.
`reactviro_create_code_environment_render`	Paid flow (no charge yet). Reserves an environment render of local AR/3D source code inside an environment and returns a signed upload URL for the zipped bundle. Charges nothing on its own; the charge lands at `reactviro_start_code_environment_render`. One run renders one entry component inside one environment.
`reactviro_start_code_environment_render`	Paid. Queues the code environment render once its bundle has uploaded, charging the team's AI budget and handing the run to a worker. Safe to retry: the charge is claimed once.
`reactviro_analyze_environment`	Paid plan. Runs the tinyvio visual-inertial tracking engine over one environment recording and reports whether tracking held: anchor drift over time, dropouts, plane detection, scale, and reprojection error. Judges the recording itself, not a scene or code bundle.