Skip to main content
Glama
arcgis-mcp-bridge

arcgis-mcp-bridge

PyPI - Version PyPI - Downloads CI Python 3.11+ License Tools Ruff uv arcgis-mcp-bridge MCP server

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-bridge

Then clone ArcGIS Pro's Python environment:

# The final JSON report contains the target `python_exe` path.
py -m arcgis_mcp.setup_env

If 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-bridge is installed into the reported arcgis-mcp-env\python.exe. Use that same interpreter for both the MCP server command and ARCPY_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

Reproducible ArcGIS Pro MCP smoke benchmark

Static analysis

Ruff clean · Mypy strict clean

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 (uv.lock)

Imperative (requirements.txt)

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:

  1. Draw a polygon on paper and photograph it.

  2. Ask Claude: "Use extract_sketch_to_gis to register this photo against my basemap and commit the result to my GDB."

  3. 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

map_layer_management

10

.aprx maps, layer order/visibility/symbology, camera, save

2

data_management

22

FC/GDB lifecycle, fields, Describe, Excel/GeoJSON/CSV exchange

3

geometry_analysis

23

Overlays, dissolve/merge, selections, joins, proximity, fishnet

4

coordinate_reference_projection

4

WKID-driven define/project for vector + raster, CRS lookup

5

raster_operations

15

Map algebra, zonal stats, DEM slope/aspect/hillshade, hydrology

6

vision_analytics

1

Sketch-to-GIS: ORB+RANSAC registration → HSV ink → GDB commit

7

export_layout

9

PDF/PNG plots, DPI control, map frames, text/legend, page size

8

editing_topology

7

Repair/check geometry, append, dedupe, diff, topology validation

9

network_analysis

4

Service areas, routing, OD cost matrix, closest facility

10

spatial_statistics

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_geometry

calculate_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's tmp_path fixture: 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 the ok-xor-error invariant on the IPC envelope.

  • tests/test_registry.py & tests/test_registry_guard.py — registry stream integrity plus generic apply_path_guard enforcement and register invariants — every schema must be a ToolInput subclass, every path_fields entry must reference a valid role, duplicate names are rejected, and every destructive spec must carry its confirm gate.

  • tests/test_worker.py — process_frame error-boundary mapping: every failure class (validation, security, license, geoprocessing, internal) maps to its distinct WorkerError.kind.

  • tests/test_config.py — Settings.from_environment validation: 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/128

04 — 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 configured allowed_roots directory. 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 .gdb container 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 sets overwrite: 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-bridge

  • An existing writable directory for ARCGIS_MCP_ALLOWED_ROOTS

  • An existing file geodatabase for ARCGIS_MCP_SCRATCH_GDB, unless <first allowed root>\scratch.gdb already exists

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-bridge

Then clone ArcGIS Pro's Python environment:

# The final JSON report contains the target `python_exe` path.
py -m arcgis_mcp.setup_env

If 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 --locked

Choose 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.worker

The interpreter referenced by ARCPY_PYTHON_PATH must be able to import the complete worker stack:

arcgis_mcp
pydantic
pydantic_core
arcpy

For 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

ARCPY_PYTHON_PATH

yes

Absolute path to the licensed worker python.exe; it must resolve arcgis_mcp, Pydantic/pydantic_core, and ArcPy

ARCGIS_MCP_ALLOWED_ROOTS

no

Windows ;-separated PathGuard boundary roots; defaults to ~/Documents/ArcGIS/Projects

ARCGIS_MCP_SCRATCH_GDB

no

Default output workspace; if omitted, defaults to <first allowed root>\scratch.gdb; the GDB must already exist

ARCGIS_MCP_LOG_FILE

no

Optional rotating log-file path

ARCGIS_MCP_LOG_LEVEL

no

DEBUG, INFO, WARNING, or ERROR; default INFO

ARCGIS_MCP_TOOL_TIMEOUT

no

Positive per-job timeout in seconds; default 600

ARCGIS_MCP_MAX_WORKERS

no

Concurrent ArcPy worker ceiling; default 2, protecting license seats and RAM

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.

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-bridge

Verify 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.exe

Do 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.gdb

It 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 Python >=3.11 package requirement

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 tools
add_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

    A3.5/5.0

    Scored across 103 tools

    Disambiguation3/5

    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.

    Naming Consistency4/5

    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.

    Tool Count1/5

    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.

    Completeness4/5

    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

    ActivityMaintained
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Drive 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.
      6
      73
      PolyForm Noncommercial 1.0.0
    • F
      license
      B
      quality
      C
      maintenance
      Enables 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.
      15
      6
      -