Date: 2025
Purpose: Highlight how MCP-powered interaction fundamentally differs from traditional interactive applications
Traditional interactive 3D applications require granular, precise control through UI elements: sliders, color pickers, numeric inputs, dropdown menus. You must know exactly what you want and how to achieve it through specific interface controls.
MCP-powered interaction allows you to describe what you want in natural language, as if you were directing a photographer or lighting designer working with a real scene. The AI assistant understands your intent and translates it into the necessary technical operations.
This document demonstrates how this natural language approach enables a fundamentally different—and more intuitive—way of interacting with 3D scenes.
If you're new to this tool, here's how to begin using natural language interaction with the 3D scene:
- Launch the Claude Desktop application on your computer
- The MCP server should be automatically configured (if you've set it up according to the setup guides)
- Open a new chat in Claude Desktop
- You'll be interacting with Claude, who has access to the 3D scene control tools
In your chat with Claude, say:
"Hello 3D app" or "How do I open the 3D application?"
Claude will provide you with the URL to access the 3D frontend application. This is typically a localhost URL (e.g., http://localhost:5173) or a deployed URL if you're using a hosted version.
- Open the URL Claude provides in your web browser
- The 3D scene will load in the browser
- Keep Claude Desktop open—you'll be controlling the scene through Claude
Once both Claude Desktop and the 3D application are open, you can begin using natural language commands! Try starting with simple requests like:
- "Create a scene that looks cool"
- "What color is the model right now?"
- "Make the background darker"
The examples below demonstrate the full range of natural language interactions you can use.
Natural Language (MCP):
"Create a scene that looks spooky"
What happens: The AI understands "spooky" means:
- Dark background (perhaps deep purple or black)
- Low, dramatic lighting (key light at low elevation, maybe dimmed)
- Cool color tones (blues, purples)
- Possibly adjust camera for a more dramatic angle
Traditional App: You would need to:
- Open background color picker → select dark color
- Open key light controls → adjust intensity slider to ~0.3
- Open key light position controls → set elevation to ~20°
- Open key light color picker → select cool blue/purple
- Open fill light controls → reduce intensity
- Adjust camera FOV slider → increase for wider angle
- Manually fine-tune each parameter until it "looks spooky"
Key Difference: One natural sentence vs. seven precise UI manipulations
Natural Language (MCP):
"Darken the current color of the model a bit"
What happens: The AI:
- Queries the current model color
- Calculates a darker shade (reduces brightness)
- Applies the new color
Traditional App: You would need to:
- Open the model color picker
- Note the current hex value (e.g., #808080)
- Manually calculate a darker shade (e.g., #606060)
- Enter the new hex value or adjust HSL sliders
- Preview and potentially adjust again
Key Difference: Relative, contextual adjustment vs. absolute value manipulation
Natural Language (MCP):
"Nudge the model slightly counterclockwise"
What happens: The AI:
- Queries current rotation
- Applies a small counterclockwise rotation (e.g., -10°)
- Updates the scene
Traditional App: You would need to:
- Open rotation controls
- Check current Y rotation value (e.g., 45°)
- Calculate new value (e.g., 35°)
- Enter the new value in the Y rotation input field
- Or drag a rotation gizmo and hope you get the right amount
Key Difference: Directional, relative movement vs. absolute angle specification
Natural Language (MCP):
"Make the key light warmer and move it a bit to the right"
What happens: The AI:
- Queries current key light color and position
- Shifts color toward warmer tones (adds red/orange)
- Adjusts azimuth position clockwise (to the right)
- Applies both changes
Traditional App: You would need to:
- Open key light color controls
- Adjust RGB sliders or HSL to add warmth (increase red, decrease blue)
- Open key light position controls
- Check current azimuth (e.g., 45°)
- Calculate new azimuth (e.g., 60°)
- Enter new azimuth value
- Preview and potentially fine-tune both
Key Difference: Combined, contextual changes vs. separate, independent adjustments
Natural Language (MCP):
"Create a scene that looks cool and modern"
What happens: The AI interprets "cool and modern" as:
- Clean, minimal background (perhaps light gray or white)
- Balanced, even lighting
- Cool color palette (blues, teals)
- Possibly adjust camera for a clean, professional view
Traditional App: You would need to:
- Set background color (multiple clicks/inputs)
- Configure key light intensity, position, color, size
- Configure fill light intensity, position, color, size
- Adjust camera distance and FOV
- Fine-tune model color to match aesthetic
- Iterate through all parameters until achieving desired look
Key Difference: High-level aesthetic goal vs. low-level parameter tweaking
Natural Language (MCP):
"Make the fill light half as bright as the key light"
What happens: The AI:
- Queries key light intensity (e.g., 1.0)
- Queries fill light intensity (e.g., 0.8)
- Calculates target fill light intensity (0.5)
- Adjusts fill light intensity
Traditional App: You would need to:
- Open key light controls → note intensity value (e.g., 1.0)
- Open fill light controls → note current intensity (e.g., 0.8)
- Calculate: 1.0 / 2 = 0.5
- Enter 0.5 in fill light intensity input
- Verify the relationship visually
Key Difference: Relative relationship specification vs. absolute value calculation
Natural Language (MCP):
"Warm up the scene a bit"
What happens: The AI understands this means:
- Adjust key light color toward warmer tones (more red/orange)
- Possibly adjust fill light to complement
- Maybe adjust model color slightly warmer
- Maintains overall lighting balance
Traditional App: You would need to:
- Open key light color picker
- Manually adjust toward warmer tones (increase red, decrease blue in RGB)
- Open fill light color picker
- Adjust fill light similarly
- Open model color picker
- Adjust model color to complement
- Preview and iterate
Key Difference: Holistic scene adjustment vs. individual element manipulation
Natural Language (MCP):
"Zoom in closer and make the background darker"
What happens: The AI:
- Adjusts camera distance (dollies in)
- Possibly adjusts FOV for tighter framing
- Darkens background color
Traditional App: You would need to:
- Open camera controls
- Adjust distance slider (or enter specific value)
- Possibly adjust FOV slider
- Open background color picker
- Select darker color
- Preview and adjust both until satisfied
Key Difference: Combined, goal-oriented changes vs. separate parameter adjustments
Natural Language (MCP):
"If the background is dark, make it lighter. Otherwise, tell me what color it is."
What happens: The AI:
- Queries current background color
- Calculates brightness
- Either lightens the color or reports the current color
- Makes intelligent decision based on actual state
Traditional App: You would need to:
- Open background color picker
- Visually assess if it's dark
- If dark, manually adjust to lighter shade
- If not dark, note the color value
- No conditional logic—you do the thinking
Key Difference: Context-aware, conditional logic vs. manual assessment and action
Natural Language (MCP):
"Move the key light toward the northeast"
What happens: The AI:
- Queries current key light position
- Calculates direction toward northeast (azimuth ~45°)
- Adjusts position incrementally toward that direction
Traditional App: You would need to:
- Open key light position controls
- Check current azimuth value (e.g., 30°)
- Know that northeast is ~45°
- Calculate adjustment needed (15° clockwise)
- Enter new azimuth value or drag control
- Preview and adjust
Key Difference: Directional, intuitive movement vs. coordinate-based calculation
Natural Language (MCP):
"Make it more dramatic"
What happens: The AI interprets "dramatic" as:
- Higher contrast lighting (increase key light, decrease fill light)
- Possibly adjust camera for more dramatic angle
- Maybe darken background
- Adjust lighting positions for more dramatic shadows
Traditional App: You would need to:
- Understand what "dramatic" means technically
- Adjust multiple lighting parameters
- Adjust camera settings
- Adjust background
- Iterate through all parameters
- Visually assess if it's "dramatic enough"
Key Difference: Subjective aesthetic goal vs. technical parameter manipulation
Natural Language (MCP):
"Is the key light brighter than the fill light? If not, make it brighter."
What happens: The AI:
- Queries both light intensities
- Compares values
- Adjusts key light if needed to be brighter than fill light
Traditional App: You would need to:
- Open key light controls → note intensity
- Open fill light controls → note intensity
- Compare values mentally
- If key light isn't brighter, calculate target value
- Adjust key light intensity
- Verify the relationship
Key Difference: Comparative logic and automatic adjustment vs. manual comparison and calculation
- Mode: Direct manipulation of UI controls
- Language: Technical parameters (hex codes, angles, intensities)
- Granularity: One parameter at a time
- Context: You must maintain mental model of current state
- Iteration: Manual trial and error
- Thinking: You do the planning, calculation, and execution
- Mode: Natural language description of desired outcome
- Language: Everyday language (spooky, warm, nudge, dramatic)
- Granularity: High-level goals that translate to multiple operations
- Context: AI queries and maintains state awareness
- Iteration: Conversational refinement ("a bit more", "slightly", "perfect")
- Thinking: AI handles planning, calculation, and execution
Users don't need to understand:
- Color theory (RGB, HSL, hex codes)
- Lighting terminology (key light, fill light, intensity)
- Camera concepts (FOV, dolly, azimuth, elevation)
- 3D coordinate systems
They can describe what they want in familiar terms.
Natural language commands can accomplish in seconds what would take minutes of precise UI manipulation.
Users can experiment with ideas ("make it spooky", "make it cool") without knowing how to achieve them technically.
Conversational refinement ("a bit darker", "slightly more", "perfect") enables rapid iteration toward desired results.
Natural language preserves the user's intent and aesthetic goals, rather than forcing them to translate those goals into technical parameters.
Think of the difference between:
- Traditional App: Being a lighting technician who must manually adjust every dial, slider, and control to achieve a look
- MCP Approach: Being a director who can say "make it more dramatic" and have a skilled technician (the AI) translate that into the necessary technical adjustments
The MCP approach brings the director's perspective to 3D scene creation, rather than requiring users to become technicians.
The MCP server approach doesn't just make 3D scene manipulation easier—it fundamentally changes the mode of interaction from technical parameter manipulation to natural language description. This enables users to think and communicate about scenes in the same way they would describe real-world scenes, lighting setups, and visual aesthetics.
This is the key selling point: You can talk about the scene as if it were real, and the AI makes it happen.
Related Documents:
bidirectional-communication-testing.md- Technical testing scenarioshigh-level-command-language-notes.md- Architecture detailsstate-manipulation.md- Available tools and functions