Cesium Mcp Runtime

by gaopengbin

388 downloads

Not rated

GitHub

Developer Tools

About

MCP server that enables AI agents to control CesiumJS 3D globe with natural language. Supports camera flight, entity management, imagery layers, terrain, GeoJSON, trajectory playback, and interactive picking. Works with Claude Desktop, VS Code Copilot, Cursor and any MCP-compatib

Details

Author: gaopengbin
Downloads: 388
Categories: Developer Tools

- 19 MCP tools for full CesiumJS control via natural language
- Camera: flyTo, setView, getView, zoomToExtent
- Entities: addMarker, addLabel, highlight, removeLayer
- Layers: loadImageryService, load3dTiles, addGeoJsonLayer, addHeatmap
- Terrain: loadTerrain, setBasemap
- Interaction: screenshot, playTrajectory
- 2 resources: scene state and entity list
- Architecturally bridges AI ↔ MCP stdio ↔ Node.js ↔ WebSocket ↔ Browser ↔ CesiumJS Viewer

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Cesium Mcp Runtime

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

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

JSON

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

JSON

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

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

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

JSON

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

JSON

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

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

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

JSON

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

JSON

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

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

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

JSON

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

JSON

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

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

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

JSON

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

JSON

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

From the repository

Install cesium-mcp-bridge in your CesiumJS application, register the viewer with CesiumMCPBridge.register(viewer), then configure your MCP client to run npx cesium-mcp-runtime as the server command.

`flyTo`

Animate the camera to a geographic location. Use for visible navigation requested by the user. Returns { success: boolean, message?: string, error?: string }.

`setView`

Set the camera position immediately without animation. Use for deterministic setup or instant view changes. Returns { success: boolean, message?: string, error?: string }.

`getView`

Get the current camera position and orientation. Returns { success, data: { longitude, latitude, height, heading, pitch, roll }, message? }.

`zoomToExtent`

Animate the camera to a west/south/east/north bounding box. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`saveViewpoint`

Save the current camera state under a page-local name. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`loadViewpoint`

Restore a previously saved page-local camera state. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`listViewpoints`

List camera viewpoints saved in the current page. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`exportScene`

Export the current view, layer, and entity state as JSON. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`addMarker`

Add a point marker at geographic coordinates. Returns { success, data: { entityId }, message? }; keep entityId for removeEntity.

`addLabel`

Add property-based text labels for GeoJSON features. Returns { success, data: { labelCount: integer }, message? }.

`addModel`

Add a glTF or GLB model at geographic coordinates. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`addPolygon`

Draw a polygon area from geographic coordinate tuples. Returns { success, data: { entityId }, message? }; keep entityId for removeEntity.

`addPolyline`

Draw a path or route from geographic coordinate tuples. Returns { success, data: { entityId }, message? }; keep entityId for removeEntity.

`updateEntity`

Update the position, appearance, label, or visibility of an entity. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`removeEntity`

Remove one entity created by an entity tool. Returns { success, message? } or { success: false, error } when entityId is not found.

`batchAddEntities`

Add multiple supported entities in one page operation. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`queryEntities`

Query page entities by name, type, or geographic extent. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`getEntityProperties`

Read the properties and graphics metadata for one entity. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`addGeoJsonLayer`

Add a styled GeoJSON Point, LineString, or Polygon layer. Returns { success, data: { id, name, type, visible, color, dataRefId? }, message? }; use id with highlight.

`addGeoJsonPrimitive`

Render GeoJSON as Cesium primitives for large browser datasets. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`listLayers`

List all layers currently managed by the page. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`getLayerSchema`

Inspect fields, entity counts, and metadata for a layer. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`removeLayer`

Remove a managed layer from the page. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`clearAll`

Clear all layers, entities, animations, and trajectories from the scene. Returns { success, data: { removedLayers, removedEntities }, message? }.

`setLayerVisibility`

Show or hide a managed layer. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`updateLayerStyle`

Update vector, imagery, primitive, or 3D Tiles styling for a layer. Returns { success: boolean, data?: unknown, message?: string, error?: string }.

`setBasemap`

Switch the visible basemap style. Returns { success, data: { basemap }, message? }.

`screenshot`

Capture the current Cesium map view as a PNG image. Returns { success, data: { dataUrl, width, height }, message? }; dataUrl is a base64 PNG.

`highlight`

Highlight one feature or every feature in a GeoJSON layer. Returns { success: boolean, message?: string, error?: string }.

`measure`

Measure distance or area between geographic coordinate tuples. Returns { success, data: { mode, value, unit, segments?, id? }, message? }.

`list_toolsets`

List all available tool groups and their enabled status. Call this to discover additional capabilities before asking the user to configure anything.

`enable_toolset`

Enable a tool group to make its tools available. Call list_toolsets first to see available groups.

`listSessions`

List all connected browser sessions (ID and connection state) for multi-browser routing

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

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

McpServers

{
    "cesium-mcp-runtime": {
        "command": "npx",
        "args": [
            "-y",
            "cesium-mcp-runtime"
        ]
    }
}

A protocol-agnostic Cesium AI control runtime for MCP, WebMCP, function calling, and browser agents

cesium-mcp-bridgeis the protocol-agnostic Cesium command executor. Separate adapters expose it tobrowser-only agents,WebMCP browser agents,function calling, orMCP— your choice.

Four integration paths:Browser Agent(simplest, zero backend) · WebMCP (page-local browser tools) · function calling (embed in your web app) ·MCP runtime(Claude Desktop / Cursor / Dify)

The local Runtime is only required for external MCP hosts. Browser Agent, WebMCP, and function-calling integrations execute the same commands directly in the web application.

Try it now— open the live browser demo, no install, no signup.

Website·中文·Getting Started·API Reference

https://github.com/user-attachments/assets/8a40565a-fcdd-47bf-ae67-bc870611c908

Which one?Personal project or quick try → browser-agent. Let a compatible browser agent discover page-local Cesium tools → WebMCP. Existing web app embedding an AI assistant → bridge + your own function calling. Calling from Claude Desktop / Cursor / Dify → MCP runtime.

flowchart LR subgraph clients ["AI Drivers (pick one)"] BA["Browser Agent\n(in the same page)"] WM["WebMCP Agent\n(browser-provided)"] FC["Your web app\nfunction calling"] MCP["Claude / Cursor / Dify\nvia MCP runtime"] end CONTRACTS["cesium-mcp-contracts\ntool definitions"] WEBMCP["cesium-mcp-webmcp\nnative adapter"] subgraph core ["cesium-mcp-bridge (browser)"] B["60+ tools\nprotocol-agnostic dispatcher"] C["CesiumJS Viewer"] end CONTRACTS -.-> BA CONTRACTS -.-> WEBMCP BA -- "in-page call" --> B WM -- "document.modelContext" --> WEBMCP WEBMCP --> B FC -- "in-page call" --> B MCP -- "WebSocket / JSON-RPC" --> B B --> C style clients fill:#1e293b,stroke:#528bff,color:#e2e8f0 style core fill:#1e293b,stroke:#12B76A,color:#e2e8f0

The bridge remains the execution core, while contracts and protocol adapters stay separate. Pick whichever driver matches your scenario — they all reach the same Cesium command layer. On WebMCP-capable browsers,cesium-mcp-webmcpcan expose 61 browser-safe commands in 12 selectable toolsets throughdocument.modelContextwithout adding an MCP transport or backend server.

Relationship to the CesiumGS AI ecosystem

CesiumGS's newer AI work is split betweencesiumjs-ai-starter-app, a deployable application template, and cesiumjs-skills, development-time guidance for coding agents. The earlier cesium-ai-integrationsrepository contains the first-generation experiments and community contributions that helped explore this space.

cesium-mcpis an independent runtime and integration toolkit, not a continuation of the earlier WebSocket-only reference architecture. Its reusable Bridge and shared contracts work unchanged across browser-only function calling, native WebMCP, standard MCP over stdio/HTTP, and embedded desktop shells. A local WebSocket bridge is used only when an external MCP host needs to reach a live browser Viewer; it is not required for the hosted demo or page-local integrations.

The project author was an early contributor toCesiumGS/cesium-ai-integrations, contributing the Imagery server, Terrain server, and unified MCP Gateway. Those experiments informed this project's multi-protocol architecture, while the implementation, release lifecycle, and roadmap remain independent.

Path 0 — Try in 30 seconds (browser agent, recommended)

Open the live demoand ask—the hosted model is ready without a browser API key:

"Fly to the Eiffel Tower and drop a red marker"

Fork the examples/browser-agentfolder to deploy your own.

Path 1 — Expose Cesium tools through WebMCP (Chrome 149+ experimental)

The browser-agent example automatically registers all 61 browser-safe page tools whendocument.modelContextis available. Its built-in chat uses automatic toolset routing to keep each normal request at 20 tools or fewer, while still offering explicit core, single-toolset, and all-61 modes:

npm run build -w packages/cesium-mcp-bridge npm run build -w packages/cesium-mcp-webmcp npx serve . -l 4173

Openhttp://localhost:4173/examples/browser-agent/, clickStart, then inspect or execute the tools in DevTools → Application → WebMCP. Enable#enable-webmcp-testingand#devtools-webmcp-supportinchrome://flagsfor local testing.

Application developers install the adapter separately. End users only open the integrated website; they do not install npm packages or run an MCP server.

import { registerCesiumViewerWebMcp } from 'cesium-mcp-webmcp/viewer' const registration = await registerCesiumViewerWebMcp(viewer, { toolsets: 'all', excludeTools: ['geocode'], // add your own browser geocoder to expose this tool }) // Later, if the page is unmounted: registration.unregister()

See theWebMCP adapter APIfor custom integrations. For a complete npm + Vite application, start from the WebMCP integration example.

Path 2 — Embed in your own web app (function calling)

import { CesiumBridge } from 'cesium-mcp-bridge'; const bridge = new CesiumBridge(viewer); // Then: send the bridge's tool schema to any LLM that supports function/tool calling, // route the model's tool calls to bridge.execute(name, params).

See examples/browser-agent/index.htmlfor a complete loop with OpenAI-compatible APIs.

Path 3 — Use from Claude Desktop / Cursor / Dify (MCP)

Ordinary MCP users need only the Runtime package. It includes the browser Bridge bundle and a built-in Viewer athttp://localhost:9100/; installcesium-mcp-bridgeseparately only when integrating a custom page.

# Stable channel — npm latest, MCP SDK v2 npx -y cesium-mcp-runtime # HTTP mode npx -y cesium-mcp-runtime --transport http --port 3000

The stable release serves existing MCP2025-11-25clients and the new2026-07-28protocol from the same stdio/HTTP entry. It uses the stable TypeScript SDK v2 and passes the officialserver-statelessconformance scenario (28/28).

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

Tools are organized into12 toolsets. Default mode enables 4 core toolsets (30 tools). SetCESIUM_TOOLSETS=allfor everything, or let the AI discover and activate toolsets dynamically at runtime.

Canonical contracts: Tool descriptions default to English; setCESIUM_LOCALE=zh-CNfor Chinese. Titles, behavior annotations, localized descriptions, defaults, input validation, MCP output schemas, and structured results all come from the shared JSON Schemas incesium-mcp-contracts. Textcontentremains available for older clients.

Seeexamples/minimal/for a complete working demo.

git clone https://github.com/gaopengbin/cesium-mcp.git cd cesium-mcp npm install npm run build npm test npm run test:contracts npm run test:schema-compat npm run test:routing npm run test:model-tools npm run eval:model-tools npm run test:e2e:packed

test:contractsis the focused parity gate for MCP Runtime metadata, WebMCP registration, Function Calling definitions, provider Schema portability, and the 60-tool Bridge Executor Registry. Runtest:schema-compatdirectly for actionable OpenAI, Azure, VS Code MCP, and WebMCP Schema diagnostics.test:routingevaluates bilingual and multi-intent Browser Agent requests across all 12 toolsets, checking required-tool recall and the 20-tool automatic-routing budget.test:model-toolsverifies the provider-neutral multi-turn scoring harness.eval:model-toolsperforms a no-network routing preflight by default; add an explicit provider and--liveto measure real tool choice, argument validity, and required-tool completion. See Model Tool Evaluation.test:e2e:packedbuilds npm tarballs, installs them in a clean temporary project, opens the real Cesium Viewer, and verifies a Runtime-WebSocket-Bridge command round trip.

Version format:{CesiumMajor}.{CesiumMinor}.{MCPPatch}

Official CesiumJS releases are reviewed before the compatibility baseline is bumped; the project does not automatically claim support for a newer release without Bridge verification.

- mapbox-mcp— AI control for Mapbox GL JS
- openlayers-mcp— AI control for OpenLayers

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

Create crafted UI components inspired by the best 21st.dev design engineers.

Bring agent evaluations, observability, and synthetic test set generation directly into your IDE for free with Galileo's new MCP server

An MCP server to help AI assistants to answer questions and generate AccelByte Extend SDK code more effectively .

MCP server for AI Diagram Maker — generate beautiful software engineering diagrams directly inside Cursor, Claude Desktop, Claude Code, or any MCP-compatible AI agent

ALAPI MCP Tools,Call hundreds of API interfaces via MCP

AI-powered SVG animation generator that transforms static files into animated SVG components using the Allyson platform

MCP server that gives AI assistants on-demand access to 1,500+ amCharts docs, ~300 code examples, and 1000+ class API references.

APIMatic MCP Server is used to validate OpenAPI specifications using APIMatic. The server processes OpenAPI files and returns validation summaries by leveraging APIMatic’s API.

One shared context layer for AI agents and humans — live API specs, DB schemas, and versioned contracts across repos so every agent and teammate works from the same source of truth.

Build and deploy full-stack Next.js apps with 98 tools for React, AWS, and MongoDB

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

flyTo

setView

getView

zoomToExtent

saveViewpoint

loadViewpoint

listViewpoints

exportScene

addMarker

addLabel

addModel

addPolygon

addPolyline

updateEntity

removeEntity

batchAddEntities

queryEntities

getEntityProperties

addGeoJsonLayer

addGeoJsonPrimitive

listLayers

getLayerSchema

removeLayer

clearAll

setLayerVisibility

updateLayerStyle

setBasemap

screenshot

highlight

measure

list_toolsets

enable_toolset

listSessions

Claude Desktop / Cursor

McpServers

Relationship to the CesiumGS AI ecosystem

Path 0 — Try in 30 seconds (browser agent, recommended)

Path 1 — Expose Cesium tools through WebMCP (Chrome 149+ experimental)

Path 2 — Embed in your own web app (function calling)

Path 3 — Use from Claude Desktop / Cursor / Dify (MCP)

Install

More like this

Sentry

Github

Git

GitLab

Context 7

Playwright

`flyTo`

`setView`

`getView`

`zoomToExtent`

`saveViewpoint`

`loadViewpoint`

`listViewpoints`

`exportScene`

`addMarker`

`addLabel`

`addModel`

`addPolygon`

`addPolyline`

`updateEntity`

`removeEntity`

`batchAddEntities`

`queryEntities`

`getEntityProperties`

`addGeoJsonLayer`

`addGeoJsonPrimitive`

`listLayers`

`getLayerSchema`

`removeLayer`

`clearAll`

`setLayerVisibility`

`updateLayerStyle`

`setBasemap`

`screenshot`

`highlight`

`measure`

`list_toolsets`

`enable_toolset`

`listSessions`