arcgis-mcp-bridge
This server provides a secure, two-process MCP bridge to ArcGIS Pro's ArcPy engine, exposing 100 declarative geoprocessing tools for GIS data management, analysis, and visualization via JSON-RPC.
Core System
health_check— Verify the full server→worker pipeline without importing ArcPyPathGuard sandbox restricts file access to allowed roots; destructive operations (delete, overwrite, calculate, etc.) require explicit
confirm: trueTwo-process isolation: ArcPy runs in a separate worker; a crash does not kill the server
Data Management
Create, delete, copy, rename feature classes, GDBs, and datasets
Add, delete, batch-add, and calculate fields (ARCADE, SQL, PYTHON3)
Get field info, feature counts, extent, and full dataset metadata
Import/export GeoJSON, Shapefile, Excel (.xlsx), CSV
Append features, delete duplicates, compact geodatabase
Geometry & Spatial Analysis
Buffer, clip, intersect, union, erase, dissolve, merge, spatial join
Select by attribute (SQL) or spatial relationship
Near analysis, generate near table, minimum bounding geometry
Feature to point, vertices to points, multipart to singlepart, simplify, smooth
Summarize within, frequency, statistics, tabulate intersection, identity, symmetrical difference
Fishnet, eliminate polygon parts, detect feature changes, check/repair geometry, validate topology
Calculate geometry attributes, add XY coordinate fields
Map & Layer Management
List maps/layers, add/remove layers, set visibility, reorder, rename
Apply symbology from
.lyrx, zoom to layer extent, save.aprxproject
Coordinate Reference & Projection
Look up CRS details by WKID, define/assign CRS, reproject vector and raster datasets with configurable transforms
Raster Operations
Clip, resample, mosaic, extract by mask, raster calculator (map algebra)
Raster to polygon, polygon to raster, zonal statistics (as raster or table)
Slope, aspect, hillshade, contour lines, flow direction, fill sinks
Layout & Export
List layouts, export to PDF/PNG, export map view as image
Set map scale/extent, update text elements and legend, change layout page size
Spatial Statistics (some require Spatial Analyst license)
Mean center, directional distribution (standard deviational ellipse), kernel density
Network Analysis (requires Network Analyst license)
Service area polygons, route analysis, OD cost matrix, closest facility
Sketch-to-GIS Pipeline (optional)
Extract vector features from hand-drawn sketches via image registration and segmentation
Provides tools to interact with ArcGIS Pro's ArcPy engine, enabling geospatial data management, analysis, and visualization tasks such as buffer, dissolve, kernel density, network analysis, and more.
arcgis-mcp-bridge
100 declarative geoprocessing tools. Two isolated processes. One security floor.
A secure, local-first, asynchronous MCP server exposing ArcGIS Pro's ArcPy engine to Claude Desktop and other MCP hosts over stdio JSON-RPC.
Quick Start
arcgis-mcp-bridge requires Windows, a licensed ArcGIS Pro installation, and
Python 3.11 or newer for the bridge package.
Install the bootstrap package using one package manager:
# Option A — pip
py -m pip install --upgrade arcgis-mcp-bridge
# Option B — uv
uv pip install --upgrade arcgis-mcp-bridgeThen clone ArcGIS Pro's Python environment:
# The final JSON report contains the target `python_exe` path.
py -m arcgis_mcp.setup_envIf the installed console command is available on PATH,
arcgis-mcp-setup is equivalent to py -m arcgis_mcp.setup_env.
Important for Windows systems with multiple Python installations: the setup is not complete until
arcgis-mcp-bridgeis installed into the reportedarcgis-mcp-env\python.exe. Use that same interpreter for both the MCP servercommandandARCPY_PYTHON_PATH. This prevents worker failures caused by packages or native extensions being loaded from another Python environment.
See 05 — Installation for the complete setup and configuration.
Technical write-up: Building a Secure MCP Bridge for ArcGIS Pro and ArcPy
Catalog | 100 tools · 10 verticals |
Tests | 128 tests · 128/128 passing · arcpy mocked |
Real runtime evidence | |
Static analysis | Ruff clean · Mypy |
Transport | JSON-RPC 2.0 over stdio |
License | Apache-2.0 |
Related MCP server: CLI-Anything · ArcGIS Pro
Why arcgis-mcp-bridge?
Feature | arcgis-mcp-bridge | geo2004/MCP-ArcGISPro | nicogis (C#/.NET) |
Tools | 100 | ~15 | ~10 |
Dependency Sync | Deterministic ( | Imperative ( | Native NuGet |
Transport | stdio JSON-RPC | file-based IPC | Named Pipes |
Security Architecture | Documented PathGuard sandbox | None specified / default host access | None specified / default host access |
arcpy Isolation | Two-process architecture | Single process execution | Add-In in-process execution |
CI (Offline Verification) | ✅ Supported | ❌ Not available | ❌ Not available |
License | Apache-2.0 | MIT | MIT |
Highlight: Sketch → GIS Pipeline
Hand-drawn parcel boundary → photo → geodatabase feature class. ORB+RANSAC image registration, HSV ink segmentation, direct GDB commit. No manual digitizing required.
Demo coming soon. To preview the sketch-to-GIS pipeline:
Draw a polygon on paper and photograph it.
Ask Claude: "Use extract_sketch_to_gis to register this photo against my basemap and commit the result to my GDB."
The feature class appears in ArcGIS Pro — no manual digitizing.
00 — Example Prompts
After health_check succeeds, talk to Claude naturally:
"Buffer all parcels in my GDB by 50 meters and save to scratch."
"List all feature classes in C:\GIS\city.gdb starting with 'road_'."
"Dissolve the neighborhoods layer by district_id."
"Run kernel density on crime_points with a 500-meter search radius."
"Calculate slope and aspect from the DEM at C:\GIS\dem.tif."
"Find the 3 nearest facilities to each incident in my network dataset."
"Check geometry on all feature classes in my GDB and repair errors."01 — Core Architecture & Philosophy
flowchart TD
A[Claude Desktop / Cursor] -->|JSON-RPC over stdio| B[Layer A · MCP Protocol Host]
B -->|NDJSON subprocess bridge| C[Layer B · ArcPy Worker]
C --> D[ArcGIS Pro / ArcPy Runtime]Layer A — Async Event-Driven Server (arcgis_mcp/server.py).
FastMCP on the bridge interpreter. Owns the stdio channel, validates every
request against frozen Pydantic v2 contracts, dispatches work via
asyncio.create_subprocess_exec — the event loop never blocks on a
geoprocessing call and never holds a thread lock. Layer A contains zero
module-level arcpy or cv2 imports (verified by grep in the audit
gate); it cannot crash on Esri's native code because it never touches it.
Layer B — Subprocess ArcPy Isolation Worker (arcgis_mcp/worker.py).
Spawned per job on the licensed ArcGIS Pro interpreter
(ARCPY_PYTHON_PATH). The only place import arcpy is legal; cv2 loads
lazily inside the one vision tool that needs it. Worker stdout is rebound
to stderr at startup — the single sanctioned stdout write is the final
NDJSON result frame, so native ArcObjects chatter can never corrupt the
JSON-RPC channel. A native crash terminates the worker, not the server:
the parent converts a non-zero exit into a structured error frame.
Declarative registry (arcgis_mcp/registry.py).
Each tool is one ToolSpec(name, category, description, input_model, worker_fn, destructive). One generic proxy factory materializes all 100
catalog MCP endpoints in Layer A; one generic run_tool dispatcher serves
them in Layer B. The catalog is exposed alongside three core endpoints:
health_check, list_layers, and execute_spatial_tool. Adding catalog
tool #101 touches two files — never the runtime loops.
Every failure crossing the process boundary is classified:
validation · security · not_found (an input path does not exist; the
message names the field and path) · license · geoprocessing (with the full
arcpy.GetMessages() stack, or ArcPy's own message for non-geoprocessing
calls such as Describe) · internal (exception type and message; the
traceback stays in the server log).
02 — The 100-Tool Census Matrix
# | Vertical | Tools | Key capabilities |
1 |
| 10 | .aprx maps, layer order/visibility/symbology, camera, save |
2 |
| 22 | FC/GDB lifecycle, fields, Describe, Excel/GeoJSON/CSV exchange |
3 |
| 23 | Overlays, dissolve/merge, selections, joins, proximity, fishnet |
4 |
| 4 | WKID-driven define/project for vector + raster, CRS lookup |
5 |
| 15 | Map algebra, zonal stats, DEM slope/aspect/hillshade, hydrology |
6 |
| 1 | Sketch-to-GIS: ORB+RANSAC registration → HSV ink → GDB commit |
7 |
| 9 | PDF/PNG plots, DPI control, map frames, text/legend, page size |
8 |
| 7 | Repair/check geometry, append, dedupe, diff, topology validation |
9 |
| 4 | Service areas, routing, OD cost matrix, closest facility |
10 |
| 5 | Mean center, ellipse, kernel density, Gi* hot spots, Moran's I |
Total | 100 |
Esri extension licenses (Spatial, Network) are managed through one shared
context manager and checked back in via finally on normal Python exception
paths. Worker-process isolation contains native failures to the current job,
while unavailable licenses return a structured error frame instead of
terminating the MCP server.
Destructive Mutation Safety Floor
Ten state-mutating tools refuse to run without an explicit
confirm: true payload token. The gate fires in the dispatcher before
the 10–30 s arcpy import is paid, and the registry refuses to even
register a destructive spec whose contract lacks a confirm field:
append_features calculate_field define_projection
delete_dataset delete_field delete_identical
extract_sketch_to_gis near_analysis remove_layer_from_map
repair_geometrycalculate_field carries an additional expression-channel floor: the
default expression_type is ARCADE (Esri's sandboxed expression
language), and PYTHON3 — which executes code inside the worker — is
rejected at the Layer-A contract boundary unless confirm: true is
explicitly supplied. raster_calculator expressions are constrained to a
pure map-algebra grammar (identifiers, numbers, operators; no quotes, no
dunder access) by a contract validator.
03 — Automated Quality Gate & Testing
Licensed-runtime evidence is reported separately in the
benchmarks/ method card. Its committed result uses a real
ArcGIS Pro worker and a dedicated scratch GDB; it is not pooled with the mocked
unit-test count or presented as validation of all 100 geoprocessing tools.
Scope, stated plainly: the automated gate currently consists of
128 unit tests spanning the PathGuard boundary, the Pydantic contracts,
the generic registry path-guard and registration invariants, the worker's
error-boundary mapping, input-existence checks, GeoJSON import, and Settings
environment validation. It exercises
the catalog's structural contracts and every security-critical seam — it does
not claim multi-scenario validation of the 100 geoprocessing tools themselves,
which execute against a licensed ArcGIS runtime that no CI runner has.
In-memory test architecture. tests/conftest.py injects MagicMock
proxies into sys.modules["arcpy"] and sys.modules["arcpy.sa"] (with
CheckExtension answering "Available") before any package import
resolves. The entire suite executes in well under a second, with no ArcGIS
installation, no license checkout, and no Esri runtime — locally and in CI
identically.
Test scopes.
tests/test_security.py&tests/test_pathguard.py— the PathGuard boundary firewall, exercised against real directories via pytest'stmp_pathfixture: valid reads/writes inside the sandbox pass; traversal (..-segments), UNC, relative, NUL-byte, reserved-device, over-length and out-of-root paths are rejected; write discipline (ArcGIS dataset-name rules, overwrite opt-in) is enforced.tests/test_contracts.py— Pydantic contract enforcement: per-tool parameter specs, cross-field validators,frozen/extra="forbid", and theok-xor-errorinvariant on the IPC envelope.tests/test_registry.py&tests/test_registry_guard.py— registry stream integrity plus genericapply_path_guardenforcement andregisterinvariants — every schema must be aToolInputsubclass, everypath_fieldsentry must reference a valid role, duplicate names are rejected, and every destructive spec must carry itsconfirmgate.tests/test_worker.py—process_frameerror-boundary mapping: every failure class (validation, security, license, geoprocessing, internal) maps to its distinctWorkerError.kind.tests/test_config.py—Settings.from_environmentvalidation: required variables, directory/file checks, integer bounds, and the fail-fast on a missing scratch geodatabase.
The side-effect import import arcgis_mcp.tools in the registry test is
what populates the catalog; it is # noqa-pinned so no linter ever strips
it again.
Static analysis. Ruff enforces canonical formatting plus
E/W/F/I/B/RUF at 88 columns against a py311 floor (code must parse on
the oldest supported interpreter — Layer B). Turkish comments are
first-class: the dotless ı/İ are registered under
allowed-confusables, so prose is configured around, never rewritten.
Mypy runs strict = true with the Pydantic plugin across all 31 source
files.
make format # ruff format + import sorting (mutates)
make lint # ruff check, mutates nothing
make type-check # mypy --strict over arcgis_mcp/
make security-audit # live registry inspection: path roles + confirm gates
make verify-all # lint + type-check + security-audit, one gate
python -m pytest # 128/12804 — Security Framework (PathGuard Sandbox)
Every filesystem argument in every contract declares its role —
"read", "write", or "read_list" — in the model's path_fields
mapping. One shared enforcement function applies those declarations in
both processes: Layer A pre-checks before a worker is ever spawned;
Layer B re-validates because it never trusts its parent.
Two boundary controls:
validate_read(raw: str)— fully resolves the path (symlinks,.., relative segments collapsed before any comparison) and requires containment inside a configuredallowed_rootsdirectory. Existence is enforced via a deepest-existing-prefix resolution strategy: the targeted path or its filesystem-resolvable geodatabase prefix must exist. This is what makes GDB-internal datasets (…\city.gdb\roads) first-class — the.gdbcontainer is validated on the filesystem, while the logical tail is constrained to plain dataset names only arcpy can resolve.validate_write(raw: str, *, overwrite: bool)— same resolution and containment, plus ArcGIS-legal dataset naming and the overwrite discipline: an existing target is never replaced unless the request explicitly setsoverwrite: true.
Any escape pattern — traversal sequences, UNC shares, NUL bytes, reserved
device names, out-of-root targets — raises PathSecurityError
immediately: the request is answered with a structured security frame
and no subprocess is ever orchestrated for it.
05 — 📦 Installation
Choose the onboarding path that matches your use case.
Prerequisites
Windows with a licensed ArcGIS Pro installation
Python 3.11 or newer for
arcgis-mcp-bridgeAn existing writable directory for
ARCGIS_MCP_ALLOWED_ROOTSAn existing file geodatabase for
ARCGIS_MCP_SCRATCH_GDB, unless<first allowed root>\scratch.gdbalready exists
Path A: Pure PyPI Installation — Recommended for Windows Users
This is the simplest and most reliable setup for Claude Desktop and other MCP
hosts on Windows. The recommended configuration uses the same
arcgis-mcp-env\python.exe for both Layer A (the MCP server) and Layer B
(the ArcPy worker).
Choose one bootstrap installation command:
# Option A — pip
py -m pip install --upgrade arcgis-mcp-bridge
# Option B — uv
uv pip install --upgrade arcgis-mcp-bridgeThen clone ArcGIS Pro's Python environment:
# The final JSON report contains the target `python_exe` path.
py -m arcgis_mcp.setup_envIf the installed console command is available on PATH,
arcgis-mcp-setup is equivalent to py -m arcgis_mcp.setup_env.
Copy the python_exe value from the JSON report and assign it below:
$ArcGISMcpPython = "C:\...\envs\arcgis-mcp-env\python.exe"Choose one installation command:
# Standard installation
& $ArcGISMcpPython -m pip install --upgrade arcgis-mcp-bridge
# OR: include the optional OpenCV-based sketch-to-GIS extension
& $ArcGISMcpPython -m pip install --upgrade "arcgis-mcp-bridge[vision]"Do not run both commands; the second command already installs the standard
package together with the vision extra.
Use $ArcGISMcpPython as both the MCP server interpreter and
ARCPY_PYTHON_PATH. This prevents arcgis_mcp, Pydantic, pydantic-core,
and other native dependencies from being resolved from a different Python
installation.
Path B: Git Clone & Deterministic Development — GIS Contributors
This path keeps Layer A in a hermetic development environment while running
ArcPy work in a separately cloned, licensed arcgis-mcp-env worker.
# 1. Clone the repository.
git clone https://github.com/muend/arcgis-mcp-bridge.git
cd arcgis-mcp-bridge
# 2. Create the isolated development environment.
# Do not use --system-site-packages: Layer A must remain independent of arcpy.
uv venv --python "C:\Program Files\ArcGIS\Pro\bin\Python\envs\arcgispro-py3\python.exe"
# 3. Synchronize the committed dependency resolution.
uv sync --lockedChoose one worker-provisioning command:
# Standard worker
uv run python -m arcgis_mcp.setup_env --install-runtime-deps --project-root .
# OR: worker with the optional OpenCV-based sketch-to-GIS extension
uv run python -m arcgis_mcp.setup_env --with-vision --project-root .--with-vision implies runtime-dependency installation, so the two commands
should not be run consecutively.
The setup command is idempotent, accepts --env-name (default:
arcgis-mcp-env) and --dry-run, and emits a JSON report. Set
ARCGIS_CONDA_EXE if ArcGIS Pro's conda.exe is not available on PATH.
Worker Interpreter Integrity
Layer B is launched as:
ARCPY_PYTHON_PATH -m arcgis_mcp.workerThe interpreter referenced by ARCPY_PYTHON_PATH must be able to import the
complete worker stack:
arcgis_mcp
pydantic
pydantic_core
arcpyFor a first-time Windows installation, use the same
arcgis-mcp-env\python.exe for the server command and
ARCPY_PYTHON_PATH. Separate server and worker environments remain supported
for development, but the worker interpreter must contain its own compatible
installation of arcgis-mcp-bridge and all runtime dependencies.
Run this preflight check before configuring the MCP host:
$ArcGISMcpPython = "C:\...\envs\arcgis-mcp-env\python.exe"
& $ArcGISMcpPython -c "import sys, arcgis_mcp, pydantic, pydantic_core; print(sys.executable); print('Bridge runtime OK')"
& $ArcGISMcpPython -c "import arcpy; print('ArcPy', arcpy.GetInstallInfo().get('Version'))"Environment Variables
Variable | Required | Purpose |
| yes | Absolute path to the licensed worker |
| no | Windows |
| no | Default output workspace; if omitted, defaults to |
| no | Optional rotating log-file path |
| no |
|
| no | Positive per-job timeout in seconds; default |
| no | Concurrent ArcPy worker ceiling; default |
Claude Desktop Configuration
ARCPY_PYTHON_PATH is required in every configuration and must point to the
licensed interpreter reported by the setup command.
Replace every placeholder path below with an existing path on your machine. The scratch geodatabase must already exist.
Option 1: Unified PyPI Environment — Recommended on Windows
Use the same interpreter for the MCP server and ArcPy worker:
{
"mcpServers": {
"arcgis-mcp-bridge": {
"command": "C:\\...\\envs\\arcgis-mcp-env\\python.exe",
"args": [
"-m",
"arcgis_mcp.server"
],
"env": {
"ARCPY_PYTHON_PATH": "C:\\...\\envs\\arcgis-mcp-env\\python.exe",
"ARCGIS_MCP_ALLOWED_ROOTS": "C:\\GIS\\Data;C:\\Workspace",
"ARCGIS_MCP_SCRATCH_GDB": "C:\\GIS\\Data\\scratch.gdb",
"ARCGIS_MCP_MAX_WORKERS": "2"
}
}
}
}The command and ARCPY_PYTHON_PATH values should be identical in this
configuration. Use the python_exe value returned by the setup command.
Option 2: Local Git Development Environment
Use the repository .venv for Layer A and the provisioned
arcgis-mcp-env for Layer B:
{
"mcpServers": {
"arcgis-mcp-bridge": {
"command": "C:\\path\\to\\arcgis-mcp-bridge\\.venv\\Scripts\\python.exe",
"args": [
"-m",
"arcgis_mcp.server"
],
"env": {
"ARCPY_PYTHON_PATH": "C:\\...\\envs\\arcgis-mcp-env\\python.exe",
"ARCGIS_MCP_ALLOWED_ROOTS": "C:\\GIS\\Data;C:\\Workspace",
"ARCGIS_MCP_SCRATCH_GDB": "C:\\GIS\\Data\\scratch.gdb",
"ARCGIS_MCP_MAX_WORKERS": "2"
}
}
}
}This split-environment configuration assumes that the worker was provisioned
from the repository with one of the Path B setup commands above. PYTHONPATH
is not required when uv sync --locked has installed the project into the
repository .venv.
A globally resolved arcgis-mcp-server command can work, but it creates a
split-environment deployment. It is not recommended for first-time Windows
setup unless the worker environment has been provisioned and verified
separately.
After restarting the MCP host, call health_check first. It verifies the
server-to-worker IPC path and reports the selected worker interpreter without
importing ArcPy. Then run a read-only ArcGIS tool or the ArcPy preflight command
above to validate the licensed runtime.
06 — Troubleshooting
Worker process exited with code 1
If the MCP server starts but every ArcGIS tool fails, inspect the server log for the worker traceback. Common environment-related causes include:
ModuleNotFoundError: No module named 'arcgis_mcp'
ModuleNotFoundError: No module named 'pydantic_core._pydantic_core'These errors usually mean that the worker is using a different Python installation, the bridge was not installed into the worker interpreter, or the worker contains an incomplete or incompatible Pydantic installation. The recommended fix is the unified-environment configuration documented above.
For the recommended unified configuration, confirm that both values are identical:
"command": "C:\\...\\envs\\arcgis-mcp-env\\python.exe""ARCPY_PYTHON_PATH": "C:\\...\\envs\\arcgis-mcp-env\\python.exe"Install or update the bridge inside that exact interpreter:
$ArcGISMcpPython = "C:\...\envs\arcgis-mcp-env\python.exe"
& $ArcGISMcpPython -m pip install --upgrade arcgis-mcp-bridgeVerify the selected executable and bridge dependencies:
& $ArcGISMcpPython -c "import sys, arcgis_mcp, pydantic, pydantic_core; print(sys.executable); print('Bridge runtime OK')"Then verify ArcPy separately:
& $ArcGISMcpPython -c "import arcpy; print('ArcPy', arcpy.GetInstallInfo().get('Version'))"If the bridge verification still fails specifically inside pydantic_core,
reinstall Pydantic in the same environment so pip restores the matching
compiled dependency:
& $ArcGISMcpPython -m pip install --upgrade --force-reinstall --no-cache-dir "pydantic>=2.5,<3"Restart the MCP host completely after changing its Python environment or configuration.
ARCPY_PYTHON_PATH points to the wrong executable
A Windows conda environment normally places its interpreter at the environment root:
C:\...\envs\arcgis-mcp-env\python.exeDo not use another global Python installation or a nonexistent
arcgis-mcp-env\Scripts\python.exe path.
Scratch geodatabase startup error
The default scratch workspace is:
<first allowed root>\scratch.gdbIt must already exist. Create it in ArcGIS Pro or set
ARCGIS_MCP_SCRATCH_GDB to an existing file geodatabase before restarting the
MCP host.
health_check succeeds but ArcGIS tools still fail
health_check intentionally verifies the server-to-worker process boundary
without importing ArcPy. A successful result confirms IPC and interpreter
selection, but it does not prove that ArcPy or an optional Esri extension
license can be loaded.
Run the ArcPy preflight command above and inspect the structured worker error
for not_found, license, geoprocessing, or internal details.
The first ArcGIS tool call times out
Every tool call starts a fresh worker that imports ArcPy. That usually takes
10–30 s, but a cold import has been measured at ~230 s on a machine where
real-time antivirus scans ArcGIS Pro's native DLLs; later calls are fast once
the DLLs are cached. Keep ARCGIS_MCP_TOOL_TIMEOUT at its 600 s default (or
higher) on such machines. Whether to exclude the ArcGIS Pro installation from
real-time scanning is a security decision for the machine's administrator.
import_from_geojson and geometry types
ArcPy's JSONToFeatures reads a .geojson file as polygons unless told
otherwise and silently drops other geometries. The bridge therefore detects the
geometry type from the file and passes it explicitly. A file that mixes points,
lines, and polygons is rejected with a count per type; import it once per type
with geometry_type set. An import that yields zero features fails loudly
instead of returning an empty feature class.
07 — Compatibility
ArcGIS Pro | Bundled Python | Status |
3.3 | 3.11 | ✅ Reference platform |
3.4 | 3.11 | ⚠ Community-reported; verify with the preflight checks |
3.6 | 3.13 | ✅ Community-verified: full test suite and runtime benchmark (#24) |
3.7 | 3.13 | ✅ Maintainer-verified runtime benchmark (result) |
3.1–3.2 | 3.9 | ❌ Unsupported by the current |
Windows only. ArcPy requires a licensed ArcGIS Pro installation on Windows. Layer A can run on other platforms for development and mocked CI, but Layer B requires ArcGIS Pro.
The bridge package itself requires Python 3.11 or newer. ArcGIS Pro releases whose cloned Python environment is older than 3.11 cannot run the current worker package.
08 — License
Apache License 2.0. See LICENSE.
Available Tools
103 toolsadd_fieldA
Add one attribute field to an existing feature class or table using ArcPy AddField. Use this to prepare schema before imports, joins, calculations, or manual editing. Mutates the input dataset schema; the dataset must be inside a PathGuard allowed root.
Inputs: params (required). Returns: object
add_fields_batchA
Add multiple fields to an existing feature class or table in one operation using ArcPy AddFields. Use this to prepare a complete attribute schema before imports, calculations, joins, or QA/QC. Mutates the input dataset schema; field names, types, aliases, and lengths are validated before execution.
Inputs: params (required). Returns: object
add_layer_to_mapA
Add a dataset to a map inside a saved ArcGIS Pro .aprx project using arcpy.mp addDataFromPath. Use this to load feature classes, rasters, tables, or other supported GIS datasets into an existing project map before styling, exporting, or layout automation. Operates on the saved .aprx file, not a live ArcGIS Pro session, and saves the project when save=true.
Inputs: params (required). Returns: object
add_xy_coordinatesA
Add or update POINT_X and POINT_Y coordinate fields on point features using ArcPy AddXY. Use this when point coordinates are needed for export, QA/QC, labeling, tabular analysis, or integration with non-GIS systems. Mutates the input dataset by adding or updating coordinate fields, so run it on an intended working dataset.
Inputs: params (required). Returns: object
append_featuresA
Append rows from one or more feature classes or tables into an existing target dataset using ArcPy Append. Use this to load reviewed data, merge field-compatible updates, or add processed batches into a live target. This mutates the target dataset by inserting rows, so confirm=true is required.
Inputs: params (required). Returns: object
aspect_analysisA
Derive downslope aspect direction from an elevation raster using ArcPy Spatial Analyst Aspect. Use this for terrain interpretation, solar exposure, ecological modeling, hydrology, and site suitability. Requires a Spatial Analyst license and writes a new aspect raster.
Inputs: params (required). Returns: object
calculate_fieldA
Calculate values for an existing field using ArcPy CalculateField. Use this for controlled attribute updates with ARCADE, SQL, or PYTHON3 expressions. The default ARCADE mode is preferred for LLM-facing workflows; PYTHON3 executes worker-side code and, like all value overwrites, requires confirm=true.
Inputs: params (required). Returns: object
calculate_geometryA
Calculate area, length, perimeter, centroid, or point coordinate values into an attribute field using ArcPy CalculateGeometryAttributes. Use this to populate measurement fields for reporting, QA/QC, labeling, or downstream analysis. Mutates the input dataset by writing geometry values into the specified field.
Inputs: params (required). Returns: object
check_geometryA
Check a feature class for geometry problems using ArcPy CheckGeometry and write the findings to an output table. Use this as a non-mutating QA/QC step before repair_geometry, overlay, topology validation, conversion, or export. Reads the input features and writes a report table inside PathGuard allowed roots.
Inputs: params (required). Returns: object
clip_rasterA
Clip a raster by rectangle, template extent, or template polygon geometry using ArcPy management Clip. Use this to crop imagery, DEMs, or classified rasters to a study area without requiring Spatial Analyst. Reads in_raster and optional template_dataset and writes out_raster inside PathGuard roots.
Inputs: params (required). Returns: object
closest_facilityB
Find nearest facility routes for incident points using ArcPy Network Analyst MakeClosestFacilityAnalysisLayer. Use this to match demand or incident locations to hospitals, stations, schools, depots, stores, or other candidate facilities by network travel cost. Requires a Network Analyst license; supports facilities_to_find and writes solved route features to out_features.
Inputs: params (required). Returns: object
compact_gdbA
Compact an existing file geodatabase using ArcPy Compact. Use this as maintenance after heavy editing, deletion, or intermediate output cleanup to reclaim storage and improve geodatabase performance. Mutates the geodatabase storage layout but not feature content.
Inputs: params (required). Returns: object
contour_linesA
Create vector elevation isolines from a DEM raster using ArcPy Spatial Analyst Contour. Use this to generate cartographic contours, terrain analysis inputs, or elevation reference lines. Requires a Spatial Analyst license and writes a polyline feature class.
Inputs: params (required). Returns: object
copy_featuresA
Copy an existing feature class or layer to a new output feature class using ArcPy CopyFeatures. Use this to create a safe working copy while preserving geometry, attributes, schema, and spatial reference. Reads in_features and writes out_features inside PathGuard allowed roots; existing outputs require overwrite=true.
Inputs: params (required). Returns: object
create_feature_classB
Create an empty feature class inside an existing file geodatabase using ArcPy CreateFeatureclass. Use this to prepare a controlled output dataset with a chosen geometry type and optional WKID before loading, editing, or analysis. Reads the target geodatabase path inside a PathGuard allowed root and returns the created dataset.
Inputs: params (required). Returns: object
create_file_gdbA
Create a new file geodatabase using ArcPy CreateFileGDB. Use this to prepare a workspace for scratch outputs, copied data, imports, or project-specific analysis results. The parent folder must exist inside a PathGuard allowed root; the tool returns the created geodatabase path.
Inputs: params (required). Returns: object
create_fishnetA
Create a rectangular fishnet or grid feature class using ArcPy CreateFishnet from explicit origin coordinates, optional Y-axis orientation, cell width, cell height, row count, column count, label point option, and output geometry type. Use this to generate sampling grids, planning units, analysis zones, index maps, polygon tiles, or polyline grid overlays before spatial join, summarize-within, raster conversion, QA/QC, or map production. Writes out_features inside a PathGuard allowed root; existing outputs require overwrite=true.
Inputs: params (required). Returns: object
define_projectionA
Assign coordinate reference metadata to an existing dataset using ArcPy DefineProjection and a WKID or EPSG code. Use this only when the dataset coordinates are already in the specified CRS but the spatial reference is missing or unknown. This is metadata-only, does not transform coordinates, mutates the dataset definition, and requires confirm=true.
Inputs: params (required). Returns: object
delete_datasetA
Delete an existing feature class, table, raster, or geodatabase item using ArcPy Delete. This operation is irreversible and mutates local project data, so confirm=true is required. The target dataset must be inside a configured PathGuard allowed root.
Inputs: params (required). Returns: object
delete_fieldA
Delete one or more fields from an existing feature class or table using ArcPy DeleteField. Use this only when unwanted attribute columns should be permanently removed. This mutates the input schema and drops data, so confirm=true is required.
Inputs: params (required). Returns: object
delete_identicalA
Delete duplicate rows from a feature class or table using ArcPy DeleteIdentical based on selected fields and optional geometry tolerance. Use this only on an intended working dataset to remove duplicate records. This operation is irreversible and mutates the input dataset, so confirm=true is required.
Inputs: params (required). Returns: object
describe_datasetA
Describe an existing feature class, table, raster, or geodatabase item using ArcPy Describe. Use this to inspect data type, geometry type, coordinate reference system, and extent before choosing an analysis tool. Reads metadata only and does not modify the dataset.
Inputs: params (required). Returns: object
detect_feature_changesA
Detect spatial or attribute changes between updated features and a reference feature dataset using ArcPy DetectFeatureChanges. Use this for QA/QC, version comparison, update review, or identifying changed features within a search tolerance. Reads update_features and base_features and writes a new out_features change dataset without mutating the originals.
Inputs: params (required). Returns: object
directional_distributionA
Create standard deviational ellipse features using ArcPy DirectionalDistribution to summarize spatial orientation, dispersion, and directional trend. Use this for point-pattern analysis, movement corridors, incident spread, market/service-area orientation, or comparison between groups. Supports ellipse_size and optional weight_field; writes a new output feature class without modifying inputs.
Inputs: params (required). Returns: object
dissolve_featuresA
Merge adjacent or overlapping features that share attribute values using ArcPy Dissolve. Use this to generalize boundaries, aggregate parcels, zones, roads, or other features by one or more dissolve fields. Reads in_features and writes a new dissolved output feature class inside PathGuard allowed roots.
Inputs: params (required). Returns: object
eliminate_polygon_partA
Remove small polygon holes or parts using ArcPy EliminatePolygonPart and write a cleaned output feature class. Use this for cartographic cleanup, removing sliver holes, or simplifying polygon interiors by area or percentage thresholds. Reads in_features and writes out_features without modifying the source dataset.
Inputs: params (required). Returns: object
erase_featuresA
Remove portions of input features that overlap an erase layer using ArcPy Erase. Use this for exclusion zones, masking restricted areas, or subtracting one geography from another. Reads the input and overlay feature paths and writes a new output feature class without modifying the source datasets.
Inputs: params (required). Returns: object
excel_to_tableA
Import an Excel worksheet into a geodatabase table using ArcPy ExcelToTable. Use this to bring spreadsheet-based attributes, lookup tables, or external tabular data into ArcGIS. Reads an .xlsx workbook and writes a geodatabase table inside PathGuard allowed roots; existing outputs require overwrite=true.
Inputs: params (required). Returns: object
execute_spatial_toolA
Execute one allowlisted geoprocessing tool (Buffer_analysis, Clip_analysis).
Args:
tool: Allowlisted tool name, e.g. 'Buffer_analysis'.
in_features: Absolute path to the source dataset (inside allowed roots).
parameters: Tool-specific arguments. Buffer requires
'buffer_distance_or_field' (e.g. '100 Meters'); Clip requires
'clip_features' (a dataset path).
out_features: Output path. Omit to auto-name inside the scratch GDB.
overwrite: Must be true to replace an existing output (explicit opt-in).
Returns:
ExecuteSpatialToolOutput as JSON: status, output_path, messages,
elapsed_seconds.
Inputs: tool (required), parameters (required), in_features (required), overwrite, +1 more. Returns: object
export_layout_pdfA
Export a selected ArcGIS Pro layout to a PDF file using layout.exportToPDF. Use this for print-ready map sheets, reports, submittals, or archival exports with controlled DPI and image quality. Reads the .aprx project and writes out_pdf inside PathGuard allowed roots; existing files require overwrite=true.
Inputs: params (required). Returns: object
export_layout_pngA
Export a selected ArcGIS Pro layout to a PNG image using layout.exportToPNG. Use this for previews, portfolio images, web graphics, or presentation-ready map layouts with controlled DPI and optional transparency. Reads the .aprx project and writes out_png inside PathGuard allowed roots.
Inputs: params (required). Returns: object
export_map_as_imageA
Export a map view directly to a PNG image using the map defaultView, without requiring a layout. Use this for quick map snapshots, previews, or automated image generation when a formal layout is unnecessary. Reads the .aprx project and writes out_png with the requested width, height, and resolution.
Inputs: params (required). Returns: object
export_to_geojsonA
Export features to a WGS84 GeoJSON file using ArcPy FeaturesToJSON. Use this to share vector data with web maps, APIs, notebooks, or non-Esri tools. Reads in_features and writes an output .geojson file inside PathGuard allowed roots; existing files require overwrite=true.
Inputs: params (required). Returns: object
export_to_shapefileA
Export a feature class to shapefile format using ArcPy FeatureClassToShapefile. Use this when data must be shared with legacy GIS tools or systems that require shapefiles. Reads the input features and writes shapefile components into an existing output folder inside PathGuard allowed roots.
Inputs: params (required). Returns: object
extract_by_maskA
Extract raster cells inside a polygon or raster mask using ArcPy Spatial Analyst ExtractByMask. Use this to clip elevation, imagery, land-cover, suitability, or other raster data to a study area before analysis. Requires a Spatial Analyst license; reads in_raster and mask inside PathGuard roots and writes out_raster.
Inputs: params (required). Returns: object
extract_sketch_to_gisA
Sketch-to-GIS pipeline: align a smartphone photo of a hand-drawn sketch onto its printed map layout (ORB+RANSAC homography), extract the requested ink color (HSV segmentation), georeference the vectors using the layout envelope, and append Polygon/Polyline features into an existing GDB feature class. APPENDS rows — requires confirm=true. Worker env needs: pip install opencv-python-headless numpy.
Inputs: params (required). Returns: object
feature_to_csvA
Export a feature class or table to a CSV file using ArcPy ExportTable. Use this to move attribute data into notebooks, data pipelines, reports, or non-GIS tools. Reads the input table or feature class and writes a .csv output inside PathGuard allowed roots; existing files require overwrite=true.
Inputs: params (required). Returns: object
feature_to_pointA
Create representative point features from polygons or lines using ArcPy FeatureToPoint. Use this to produce centroids or guaranteed inside points for labeling, joins, sampling, or simplified analysis. Reads in_features and writes a new point feature class to out_features.
Inputs: params (required). Returns: object
feature_vertices_to_pointsA
Convert feature vertices to point features using ArcPy FeatureVerticesToPoints. Use this to extract endpoints, all vertices, midpoints, or dangle points from line or polygon geometry for QA/QC, network checks, and geometry inspection. Reads in_features and creates out_features inside PathGuard allowed roots.
Inputs: params (required). Returns: object
fill_sinksA
Fill sinks or depressions in an elevation raster using ArcPy Spatial Analyst Fill. Use this to hydrologically condition DEMs before flow direction, flow accumulation, watershed, or stream network analysis. Requires a Spatial Analyst license; optional z_limit controls maximum sink depth to fill.
Inputs: params (required). Returns: object
flow_directionB
Derive a hydrologic flow-direction raster from an elevation or surface raster using ArcPy Spatial Analyst FlowDirection. Use this before flow accumulation, watershed delineation, drainage modeling, or stream extraction. Requires a Spatial Analyst license; writes out_raster and can optionally force edge cells to flow outward.
Inputs: params (required). Returns: object
frequency_analysisA
Count unique combinations of attribute values using ArcPy Frequency. Use this to profile categorical fields, detect duplicates, summarize classes, or prepare simple frequency tables for QA/QC and reporting. Reads an input table and writes a new output table inside PathGuard allowed roots.
Inputs: params (required). Returns: object
generate_near_tableB
Create a standalone proximity table between input features and near features using ArcPy GenerateNearTable. Use this to record nearest neighbors, distances, and candidate matches without modifying the source datasets. Reads input and near feature paths and writes a new out_table inside PathGuard allowed roots.
Inputs: params (required). Returns: object
get_extentA
Return xmin, ymin, xmax, ymax, and CRS metadata for an existing dataset using ArcPy Describe().extent. Use this to understand spatial coverage before clipping, map export, fishnet creation, raster analysis, or spatial QA/QC. Reads metadata only and does not modify the dataset.
Inputs: params (required). Returns: object
get_feature_countA
Return the row or feature count for an existing dataset using ArcPy GetCount. Use this as a lightweight validation step before and after geoprocessing, filtering, import, export, or QA/QC workflows. Reads one dataset inside a PathGuard allowed root and does not modify data.
Inputs: params (required). Returns: object
get_field_infoA
List field metadata for an existing feature class or table using ArcPy ListFields. Use this to inspect schema before calculating, deleting, joining, or exporting attributes. Returns field names, types, lengths, aliases, and nullable status without modifying data.
Inputs: params (required). Returns: object
get_spatial_referenceA
Look up an ArcGIS spatial reference by WKID or EPSG code using arcpy.SpatialReference. Use this before projection workflows to verify the target CRS name, type, datum, and linear or angular units. This is a pure lookup with no filesystem input or output and does not modify datasets.
Inputs: params (required). Returns: object
health_checkA
Verify the full execution pipeline: server -> conda worker -> back.
Spawns a real worker process (without importing arcpy) and reports the
interpreter version plus configuration summary. Use this first when
diagnosing connectivity.
Inputs: no named parameters. Returns: object
hillshadeA
Create shaded relief from an elevation raster using ArcPy Spatial Analyst Hillshade. Use this for terrain visualization, map backdrops, and DEM QA/QC with controlled sun azimuth, altitude, shadow modeling, and z_factor. Requires a Spatial Analyst license.
Inputs: params (required). Returns: object
hotspot_analysisA
Run Getis-Ord Gi* hot and cold spot analysis using ArcPy HotSpots and write a feature class with GiZScore, GiPValue, and Gi_Bin results. Use this to identify statistically significant clusters of high and low values in incidents, socioeconomic indicators, service demand, or environmental measurements. Supports spatial conceptualization, distance method, and optional distance band.
Inputs: params (required). Returns: object
identity_featuresA
Overlay input features with identity features using ArcPy Identity. Use this to transfer polygon or line attributes onto another feature layer while preserving the input geometry where applicable. Reads both input datasets and writes a new output feature class inside PathGuard allowed roots.
Inputs: params (required). Returns: object
import_from_geojsonA
Convert a GeoJSON file into an ArcGIS feature class using ArcPy JSONToFeatures. Use this to bring web, API, or exchange-format vector data into a geodatabase for ArcGIS analysis. Reads an input .geojson file, detects its point, line, or polygon geometry type (set geometry_type for mixed files), and writes out_features inside PathGuard allowed roots; existing outputs require overwrite=true.
Inputs: params (required). Returns: object
intersect_featuresA
Overlay two or more feature layers using ArcPy Intersect and write only the shared geometry to a new output feature class. Use this to find areas, lines, or points common to multiple datasets while preserving selected attributes. Reads all input feature paths and writes out_features inside PathGuard allowed roots.
Inputs: params (required). Returns: object
kernel_densityA
Estimate a continuous density raster from point or polyline features using Spatial Analyst KernelDensity. Use this for hotspot surfaces, incident intensity, service demand, accessibility pressure, crime or event density, and other smoothed spatial concentration maps. Requires a Spatial Analyst license; supports population_field, cell_size, and search_radius and writes out_raster inside PathGuard roots.
Inputs: params (required). Returns: object
list_layersA
List feature classes, tables and rasters inside a file geodatabase.
Args:
workspace: Absolute path to a .gdb inside an allowed workspace root.
dataset_filter: Optional wildcard (e.g. 'roads_*'); None lists all.
Returns:
ListLayersOutput as JSON: workspace, layers[], elapsed_seconds.
Inputs: workspace (required), dataset_filter. Returns: object
list_layers_in_mapA
List layers in a selected map with visibility, group-layer status, and data source information where available. Use this to discover exact Contents-pane layer names before visibility, ordering, symbology, rename, or zoom operations. Reads the saved .aprx project only and does not modify layer state.
Inputs: params (required). Returns: object
list_layoutsA
List all layouts in a saved ArcGIS Pro .aprx project using arcpy.mp listLayouts. Use this to discover layout names, page sizes, and page units before exporting or modifying a layout. Reads the project only and does not save or mutate the .aprx file.
Inputs: params (required). Returns: object
list_mapsA
List map names inside a saved ArcGIS Pro .aprx project using aprx.listMaps. Use this discovery tool before map-scoped operations when the target map name is unknown or when validating project contents. Reads the project file only and does not modify or save it.
Inputs: params (required). Returns: object
mean_centerA
Calculate the geographic mean center of input features using ArcPy MeanCenter and write the result as a point feature class. Use this to summarize the central tendency of incidents, facilities, parcels, demand points, or grouped spatial observations. Supports optional weight_field and case_field parameters; reads in_features and writes out_features inside PathGuard allowed roots.
Inputs: params (required). Returns: object
merge_featuresA
Combine multiple compatible feature classes or layers into one output feature class using ArcPy Merge. Use this to assemble same-schema datasets from multiple sources, tiles, districts, or processing batches. Reads all input feature paths and writes one new output inside PathGuard allowed roots.
Inputs: params (required). Returns: object
minimum_bounding_geometryB
Create bounding geometries around input features using ArcPy MinimumBoundingGeometry. Use this to generate convex hulls, envelopes, circles, or other summary shapes for features or groups. Reads in_features and writes a new output feature class with the requested geometry_type and grouping behavior.
Inputs: params (required). Returns: object
mosaic_to_new_rasterA
Merge multiple raster datasets into one new raster using ArcPy MosaicToNewRaster. Use this to combine tiles, scenes, DEM sheets, or image bands into a single dataset. Reads two or more input rasters and writes a named raster into an existing folder or geodatabase.
Inputs: params (required). Returns: object
move_layer_orderA
Move a named layer before or after a reference layer in the map drawing order using map.moveLayer. Use this to control cartographic stacking, for example placing boundaries above imagery or analysis results above base layers. This updates the saved .aprx project when save=true.
Inputs: params (required). Returns: object
multipart_to_singlepartA
Split multipart features into singlepart features using ArcPy MultipartToSinglepart. Use this before per-feature editing, counting, topology checks, joins, or analysis that requires one geometry part per row. Reads in_features and creates out_features without modifying the source dataset.
Inputs: params (required). Returns: object
near_analysisA
Calculate nearest-neighbor distance from each input feature to nearby features using ArcPy Near. This mutates the input dataset by adding or updating NEAR_FID and NEAR_DIST fields, so confirm=true is required. Use a copied working dataset when exposing this workflow to an LLM or automated agent.
Inputs: params (required). Returns: object
od_cost_matrixA
Solve origin-destination travel cost lines using ArcPy Network Analyst MakeODCostMatrixAnalysisLayer. Use this to measure travel time or distance between demand points and destinations such as services, jobs, facilities, stores, or transit stops. Requires a Network Analyst license; supports travel_mode and optional cutoff, then writes OD line results to out_features inside PathGuard allowed roots.
Inputs: params (required). Returns: object
polygon_to_rasterA
Convert polygon features to a raster dataset using ArcPy PolygonToRaster. Use this when vector zones, classes, parcels, or planning units need to become raster cells for map algebra, suitability modeling, or raster overlay. Reads polygon features and writes out_raster using value_field, cell_assignment, and cell_size.
Inputs: params (required). Returns: object
project_featuresA
Transform a vector feature class or layer into another coordinate reference system using ArcPy Project. Use this when feature geometry coordinates must be reprojected for overlay, distance measurement, map export, analysis, or alignment with other GIS datasets. Reads in_features, writes out_features inside PathGuard allowed roots, and supports an optional geographic transform_method when datums differ.
Inputs: params (required). Returns: object
project_rasterA
Reproject a raster dataset into another coordinate reference system using ArcPy ProjectRaster. Use this to align DEMs, imagery, classified rasters, or analysis grids with a project CRS before overlay, map algebra, extraction, or export. Reads in_raster, writes out_raster inside PathGuard allowed roots, and exposes resampling_type and optional cell_size for controlling raster cell interpolation.
Inputs: params (required). Returns: object
raster_calculatorA
Run Spatial Analyst map algebra over explicitly named raster variables using ArcPy RasterCalculator. Use this for NDVI, suitability models, binary masks, raster normalization, and cell-by-cell formulas. Requires a Spatial Analyst license; expressions may reference only declared variable_names and validated map-algebra syntax.
Inputs: params (required). Returns: object
raster_to_polygonA
Convert raster zones or classes to polygon features using ArcPy RasterToPolygon. Use this to vectorize classified rasters, suitability classes, land-cover codes, or cell regions for GIS editing, overlay, and cartographic workflows. Reads in_raster and writes out_features.
Inputs: params (required). Returns: object
remove_layer_from_mapA
Remove a named layer from a map inside a saved ArcGIS Pro .aprx project using map.removeLayer. Use this for controlled map cleanup before export, packaging, or automated project updates. This changes the map contents but does not delete the underlying dataset; confirm=true is required because the project structure is mutated.
Inputs: params (required). Returns: object
rename_datasetA
Rename an existing dataset within its current workspace using ArcPy Rename. Use this for controlled cleanup of intermediate feature classes, tables, or rasters. This mutates the workspace namespace but does not edit feature geometry or attribute values; the dataset path must be inside a PathGuard allowed root.
Inputs: params (required). Returns: object
rename_layerA
Rename a layer as displayed in the ArcGIS Pro Contents pane by updating lyr.name. Use this to make automated map outputs clearer before export, handoff, or presentation. This renames the map layer only, does not rename the underlying dataset, and saves the .aprx project when save=true.
Inputs: params (required). Returns: object
repair_geometryA
Repair invalid feature geometry in place using ArcPy RepairGeometry. Use this after check_geometry reports geometry problems or before overlay, topology, network, or export operations that require valid shapes. This rewrites geometry and may delete null geometries, so confirm=true is required.
Inputs: params (required). Returns: object
resample_rasterB
Change raster cell size using ArcPy Resample. Use this to align resolution before overlay, modeling, visualization, or export. Reads one input raster and writes out_raster inside PathGuard roots; choose a resampling method appropriate for categorical or continuous data.
Inputs: params (required). Returns: object
route_analysisA
Solve the best route through ordered stop points using ArcPy Network Analyst MakeRouteAnalysisLayer. Use this for A-to-B routing, multi-stop field visits, logistics paths, inspection sequences, or travel-time analysis over a configured network dataset. Requires a Network Analyst license; reads stops and writes solved route features to out_features.
Inputs: params (required). Returns: object
save_projectA
Explicitly save a saved ArcGIS Pro .aprx project using aprx.save. Use this after a sequence of map, layer, layout, visibility, camera, or symbology changes when the project must be persisted before export or handoff. Operates on the saved .aprx file and returns the saved project path.
Inputs: params (required). Returns: object
select_by_attributeA
Materialize a SQL attribute query into a new feature class using ArcPy Select. Use this when a stateless MCP workflow needs a saved subset rather than an in-memory layer selection. Reads in_features, applies where_clause, and writes the selected rows to out_features.
Inputs: params (required). Returns: object
select_by_locationA
Materialize a spatial relationship selection into a new feature class using a MakeFeatureLayer, SelectLayerByLocation, and CopyFeatures pipeline. Use this to persist features that intersect, contain, are within, or are near another dataset. Writes the selected result to out_features and removes the temporary layer.
Inputs: params (required). Returns: object
service_areaA
Solve reachable service area polygons around facility points using ArcPy Network Analyst MakeServiceAreaAnalysisLayer. Use this to map accessibility around schools, hospitals, stations, depots, stores, or emergency facilities at one or more travel cutoffs. Requires a Network Analyst license; reads a network_dataset and facilities, then writes solved polygon features to out_features inside PathGuard roots.
Inputs: params (required). Returns: object
set_layer_symbologyA
Apply cartographic symbology from a source .lyrx layer file to a named target layer using ArcPy ApplySymbologyFromLayer. Use this to standardize colors, classifications, labels, renderers, and map styling before export or project delivery. Reads the target layer and .lyrx file inside PathGuard allowed roots and saves the .aprx project when save=true.
Inputs: params (required). Returns: object
set_layer_visibilityA
Show or hide a named layer in a selected ArcGIS Pro map by updating lyr.visible. Use this before layout or map export to control which datasets appear in the final map. This mutates layer visibility in the saved .aprx project when save=true but does not alter the source dataset.
Inputs: params (required). Returns: object
set_layout_sizeA
Change the physical page width and height of a selected ArcGIS Pro layout using layout.pageWidth and layout.pageHeight. Use this to switch between sheet sizes, portfolio formats, report pages, or print/export templates. This modifies the layout and saves the .aprx project when save=true.
Inputs: params (required). Returns: object
set_map_extent_from_layerA
Set a layout map frame extent to match a named layer using mf.getLayerExtent and mf.camera.setExtent. Use this before exporting a layout so the final map focuses on a dataset, study area, boundary, or analysis result. This changes the map frame camera and saves the .aprx project when save=true.
Inputs: params (required). Returns: object
set_map_scaleA
Set the camera scale denominator for a selected layout map frame using arcpy.mp camera.scale. Use this before exporting a layout when the map must be fixed to a known scale such as 1:1000 or 1:50,000. This updates the .aprx project when save=true.
Inputs: params (required). Returns: object
simplify_featuresA
Simplify polygon or polyline geometry using ArcPy SimplifyPolygon or SimplifyLine after detecting the input shape type. Use this to reduce vertex density for cartography, web export, performance, or scale-appropriate analysis. Writes a simplified output feature class and does not mutate the source features.
Inputs: params (required). Returns: object
slope_analysisA
Derive slope from an elevation raster using ArcPy Spatial Analyst Slope. Use this in terrain, hydrology, accessibility, hazard, and site suitability workflows. Requires a Spatial Analyst license; writes a slope raster in degrees or percent rise using z_factor.
Inputs: params (required). Returns: object
smooth_featuresB
Smooth polygon or polyline geometry using ArcPy SmoothPolygon or SmoothLine after detecting the input shape type. Use this for cartographic cleanup where angular boundaries or lines need a more generalized appearance. Writes a new smoothed output feature class without modifying the source dataset.
Inputs: params (required). Returns: object
spatial_autocorrelationA
Calculate Global Moran's I using ArcPy SpatialAutocorrelation and return scalar statistics including Moran's Index, z-score, and p-value. Use this to test whether a numeric attribute is clustered, dispersed, or spatially random before choosing local hotspot, cluster, or spatial modeling workflows. Reads in_features only and does not create or modify datasets.
Inputs: params (required). Returns: object
spatial_joinA
Join attributes from one feature layer to another based on spatial relationships using ArcPy SpatialJoin. Use this to count, summarize, or transfer nearby, contained, intersecting, or matching feature attributes into a new output feature class. Reads target_features and join_features and writes out_features inside PathGuard roots.
Inputs: params (required). Returns: object
statistics_analysisB
Calculate summary statistics for numeric or categorical fields using ArcPy Statistics. Use this to aggregate counts, sums, means, minima, maxima, standard deviations, or grouped statistics before reporting or joining results back to features. Reads an input table and writes a new output table.
Inputs: params (required). Returns: object
summarize_withinA
Summarize features that fall within polygon areas using ArcPy SummarizeWithin. Use this to count or aggregate points, lines, or polygons by administrative zones, grid cells, parcels, buffers, or service areas. Reads boundary polygons and summary features, then writes a new summarized output feature class.
Inputs: params (required). Returns: object
symmetrical_differenceA
Create the non-overlapping parts of two feature layers using ArcPy SymmetricalDifference. Use this to compare boundaries, detect areas present in only one of two datasets, or isolate disagreement between two polygon/line sources. Writes a new output feature class and does not modify the inputs.
Inputs: params (required). Returns: object
table_to_excelA
Export an attribute table or feature class table to an Excel workbook using ArcPy TableToExcel. Use this to share tabular GIS attributes with analysts, reports, or spreadsheet workflows. Reads the input table and writes an .xlsx file inside PathGuard allowed roots; existing files require overwrite=true.
Inputs: params (required). Returns: object
tabulate_intersectionB
Cross-tabulate intersections between zone features and class features using ArcPy TabulateIntersection. Use this to quantify how much of each class falls inside each zone, such as land-use area by district or habitat type by planning unit. Writes a standalone output table.
Inputs: params (required). Returns: object
topology_checkA
Validate a geodatabase topology using ArcPy ValidateTopology. Use this to refresh topology rule validation after editing, appending, repair, or geometry cleanup workflows. Reads the topology dataset and returns validation metadata; inspect the topology error feature classes in ArcGIS Pro for rule violations.
Inputs: params (required). Returns: object
union_featuresA
Overlay two or more polygon feature layers using ArcPy Union and write a new polygon feature class containing all combined areas. Use this to compare zoning, land-use, administrative, or planning layers while retaining attributes from each input. Reads input features and writes out_features inside PathGuard allowed roots.
Inputs: params (required). Returns: object
update_legendA
Add or remove a layer entry in a selected layout legend using arcpy.mp legend addItem or removeItem. Use this to synchronize legends with automated layer changes before exporting maps. This modifies the layout legend and saves the .aprx project when save=true.
Inputs: params (required). Returns: object
update_text_elementA
Update the text content of a named layout text element using arcpy.mp layout elements. Use this to automate titles, dates, subtitles, map numbers, project names, notes, or report labels before export. This modifies the selected layout and saves the .aprx project when save=true.
Inputs: params (required). Returns: object
zonal_statisticsA
Calculate one raster statistic per zone and write the result as a raster using ArcPy Spatial Analyst ZonalStatistics. Use this when each zone should receive a MEAN, SUM, MIN, MAX, or similar value from an input value raster. Requires a Spatial Analyst license.
Inputs: params (required). Returns: object
zonal_statistics_as_tableA
Calculate zonal statistics and write the results to a standalone table using ArcPy Spatial Analyst ZonalStatisticsAsTable. Use this to summarize raster values by districts, parcels, watersheds, grid cells, or other zone datasets. Requires a Spatial Analyst license.
Inputs: params (required). Returns: object
zoom_to_layerA
Set the selected map's default camera extent to match a named layer's data extent. Use this before exporting a map view or reopening the .aprx so the map focuses on a study area, boundary, analysis result, or target dataset. Reads the layer data source extent, updates the map defaultCamera, and saves the project when save=true.
Inputs: params (required). Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 103 tools
Most tools map cleanly to distinct ArcPy operations, but several near-neighbor pairs exist (list_layers/list_layers_in_map, zonal_statistics/zonal_statistics_as_table, get_extent/describe_dataset) that could lead to misselection. The descriptions are generally strong enough to disambiguate with careful reading, but the sheer number of metadata, QA, and overlay tools creates boundary overlap.
The set overwhelmingly follows a clear snake_case verb_noun convention (create_feature_class, delete_field, project_raster, intersect_features). A few noun-style analysis names (service_area, hotspot_analysis, od_cost_matrix, raster_calculator) and converter names (feature_to_csv, excel_to_table) break the pattern slightly, but the naming remains predictable.
103 tools is an extreme surface for a single MCP server, far past the 50+ threshold. Even if each ArcPy wrapper is individually useful, an agent would face severe selection overhead and prompt/context burden; a focused server split by domain would be more coherent.
The tool surface spans geodatabase management, vectors, rasters, network analysis, spatial statistics, and map/layout automation, covering most common GIS workflows end to end. Gaps include row-level feature editing/update/delete, a table join field operation, and dedicated buffer/clip tools (currently hidden inside execute_spatial_tool), but these are workable rather than fatal.
Maintenance
Related MCP Connectors
MCP server for mandates, delegation, policy-gated execution, credential grants, and audit.
Ovanek MCP: Model Context Protocol server for Ovanek platform tools; writes are dry-run by default.
Guarded MCP server for agent-readable business truth, provenance, readiness, and discovery.
Headless CAD engine & MCP server for 2D/3D drafting, solids, DXF/SVG export, and automation.
Related MCP Servers
- AlicenseCqualityDmaintenanceA local MCP server that enables AI clients to read ArcGIS Pro project information and execute ArcPy geoprocessing in the native ArcGIS Pro Python environment.13106MIT
- AlicenseAqualityCmaintenanceDrive Esri's ArcGIS Pro from an AI agent — the ArcGIS Pro counterpart to QGIS MCP. A headless ArcPy CLI plus an in-process .NET 8 add-in that exposes the live Pro session as MCP tools (ping, zoom_to, query, run_gp, export_layout) so an agent drives the running project while you watch.673PolyForm Noncommercial 1.0.0
- AlicenseNot gradedqualityDmaintenanceConnects QGIS to an LLM through the Model Context Protocol, allowing agentic interaction with and control of QGIS for prompt-assisted project creation, layer loading, code execution, and more.GPL 3.0
- FlicenseBqualityCmaintenanceEnables safe local MCP-based control of ArcMap Desktop 10.8, allowing read-only inspection of map documents, layers, datasets, and execution of allowlisted geoprocessing tools through ArcPy.156-