AuroraView MCP Server

MCP (Model Context Protocol) Server for AuroraView - enabling AI assistants to interact with WebView applications in standalone mode and DCC environments (Maya, Blender, Houdini, etc.).

Features

• Instance Discovery: Automatically discover running AuroraView instances
• CDP Connection: Connect to WebView2 instances via Chrome DevTools Protocol
• API Bridge: Call Python backend APIs through the JS bridge
• UI Automation: Click, fill, screenshot, and more
• Gallery Integration: Run and manage AuroraView samples
• DCC Support: Connect to AuroraView panels in Maya, Blender, Houdini, Nuke, Unreal

Installation

# Using pip
pip install auroraview-mcp

# Using uv (recommended)
uv pip install auroraview-mcp

# Using vx (auto-installs uv if needed)
vx uv pip install auroraview-mcp

# From source (development)
cd packages/auroraview-mcp
vx uv sync

Quick Start

Configure with Claude Desktop / CodeBuddy

Add to your MCP configuration:

{
  "mcpServers": {
    "auroraview": {
      "command": "uvx",
      "args": ["auroraview-mcp"],
      "env": {
        "AURORAVIEW_DEFAULT_PORT": "9222"
      }
    }
  }
}

Development Mode

{
  "mcpServers": {
    "auroraview": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/dcc_webview/packages/auroraview-mcp",
        "run",
        "auroraview-mcp"
      ]
    }
  }
}

Local Debugging

AuroraView MCP Server provides multiple ways to debug locally during development.

Method 1: FastMCP Built-in Client (Recommended for Unit Testing)

FastMCP 2.x includes a built-in Client that can test MCP servers without starting a separate process:

# Run all debug tests
just mcp-debug

# Interactive debug mode
just mcp-debug-interactive

Or run directly:

cd packages/auroraview-mcp
vx uv run python scripts/debug_client.py

# Test specific functionality
vx uv run python scripts/debug_client.py --test discover
vx uv run python scripts/debug_client.py --test connect --port 9222
vx uv run python scripts/debug_client.py --test interactive

Example debug script usage:

from fastmcp import Client
from auroraview_mcp.server import mcp

async def test():
    async with Client(mcp) as client:
        # List all available tools
        tools = await client.list_tools()
        print(tools)
        
        # Call a tool
        result = await client.call_tool("discover_instances", {})
        print(result)

import asyncio
asyncio.run(test())

Method 2: MCP Inspector (Recommended for Visual Debugging)

MCP Inspector provides a web-based UI for testing MCP servers:

# Start MCP Inspector
just mcp-inspector

# Or run directly
vx npx @modelcontextprotocol/inspector vx uv --directory packages/auroraview-mcp run auroraview-mcp

Then open http://localhost:5173 in your browser to:

• View all available tools and resources
• Call tools with custom parameters
• Inspect responses in real-time
• Debug connection issues

Method 3: Direct Server Execution

Run the MCP server directly for stdio-based debugging:

# Start server in development mode
just mcp-dev

# Or run directly
cd packages/auroraview-mcp
vx uv run auroraview-mcp

justfile Commands

Available Tools

Discovery Tools

Page Tools

API Tools

UI Tools

Gallery Tools

Debug Tools

DCC Tools

Usage Examples

Start and Debug Gallery

User: Start the Gallery for debugging

AI: I'll start the Gallery application.

[Call run_gallery(port=9222)]
→ Gallery started, PID: 12345, port: 9222

[Call connect(port=9222)]
→ Connected to AuroraView Gallery

[Call get_page_info]
→ Gallery is ready with API methods available

Gallery is running and ready for debugging.

Basic Workflow

User: Help me test the Gallery search function

AI: I'll connect to Gallery and test the search.

[Call discover_instances]
→ Found 1 instance on port 9222

[Call connect(port=9222)]
→ Connected to AuroraView Gallery

[Call get_snapshot]
→ Got page structure, found search box

[Call fill(selector="input[placeholder*='Search']", value="cookie")]
→ Entered search term

[Call take_screenshot]
→ Screenshot shows search results

Search function works correctly.

Running Samples

User: Run the hello_world sample

AI: [Call run_sample(name="hello_world")]
→ Sample started, PID: 12345

[Call list_processes]
→ Shows running processes

Sample successfully started.

DCC Environment

User: Test the asset browser panel in Maya

AI: I'll connect to Maya's AuroraView panel.

[Call list_dcc_instances]
→ Found Maya 2025 instance, port 9223, panel: "Asset Browser"

[Call connect(port=9223)]
→ Connected to Maya Asset Browser

[Call get_dcc_context]
→ DCC: Maya 2025.1, Scene: /projects/scene.ma, Selection: ["pCube1"]

[Call execute_dcc_command(command="maya.cmds.ls", kwargs={"selection": True})]
→ Returns: ["pCube1", "pSphere1"]

[Call sync_selection]
→ DCC and WebView selections are in sync

Panel is working correctly in Maya.

DCC Timeline Control

User: Go to frame 50 in Maya

AI: I'll set the current frame.

[Call get_dcc_timeline]
→ Current: 1, Range: 1-120, FPS: 24

[Call set_dcc_frame(frame=50)]
→ Frame set to 50

[Call get_dcc_scene_info]
→ Scene info with current frame at 50

Frame has been set to 50.

Resources

The server also provides MCP resources:

Environment Variables

Development

# Install dev dependencies
cd packages/auroraview-mcp
vx uv sync

# Run tests
just mcp-test

# Run with coverage
just mcp-test-cov

# Lint and format
just mcp-lint
just mcp-format

# Full CI check
just mcp-ci

Architecture

┌─────────────────────────────────────────────────────────────┐
│                      AI Assistant                            │
│                 (Claude, GPT, etc.)                         │
└─────────────────────────────────────────────────────────────┘
                              │
                              │ MCP Protocol (stdio)
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                  AuroraView MCP Server                       │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐   │
│  │  Discovery  │ │   Tools     │ │     Resources       │   │
│  │   Module    │ │   Module    │ │      Module         │   │
│  └─────────────┘ └─────────────┘ └─────────────────────┘   │
│         │               │                   │               │
│         └───────────────┼───────────────────┘               │
│                         │                                    │
│              ┌──────────┴──────────┐                        │
│              │   Connection Pool   │                        │
│              └──────────┬──────────┘                        │
└─────────────────────────┼───────────────────────────────────┘
                          │
          ┌───────────────┼───────────────┐
          │               │               │
          ▼               ▼               ▼
    ┌──────────┐   ┌──────────┐   ┌──────────┐
    │ WebView  │   │ WebView  │   │ WebView  │
    │ Instance │   │ Instance │   │ Instance │
    │  (CDP)   │   │  (CDP)   │   │  (CDP)   │
    └──────────┘   └──────────┘   └──────────┘

Related

• AuroraView - Main project
• MCP Protocol - Model Context Protocol
• FastMCP - Fast, Pythonic MCP framework
• MCP Inspector - MCP debugging tool

License

MIT License - see LICENSE for details.