The GIS MCP Server connects LLMs to Python GIS libraries (primarily Shapely and PyProj) to perform geospatial operations and transformations, including:
Geometric Operations: Buffer, intersection, union, difference, symmetric difference, and convex hull
Property Calculations: Centroid, bounds, coordinates, length, area, and geometry type identification
Coordinate Transformations: Convert between different Coordinate Reference Systems (CRS)
Geodetic Calculations: Calculate distances, areas, and points based on geodetic principles
Geometry Manipulation: Rotate, scale, translate, triangulate, and simplify geometries
Validation: Check if geometries are valid and make them valid if needed
Advanced Spatial Analysis: Create Voronoi diagrams, calculate minimum rotated rectangles, and perform unary unions
CRS Information: Retrieve information about available CRS, including UTM and geocentric systems
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@GIS MCP Server calculate the distance between Central Park and Times Square in New York City"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
GIS-MCP is an open-source Model Context Protocol (MCP) server that connects AI assistants and Large Language Models (LLMs) with GIS and geospatial operations.
It enables AI agents to perform geospatial analysis, spatial data processing, vector and raster operations, coordinate transformations, spatial statistics, mapping, and other GIS workflows through MCP-compatible clients.
🌐 Official Documentation: https://gis-mcp.com
📦 PyPI: https://pypi.org/project/gis-mcp/
💻 Source Code: https://github.com/mahdin75/gis-mcp
92+ GIS tools across Shapely, GeoPandas, PyProj, Rasterio, PySAL, visualization, satellite imagery, climate, ecology, movement, and land-cover data.
Category | Badges |
Package |
|
Installation & Transport |
|
Storage |
|
Data Sources |
|
Agentic AI |
|
Community |
|
Current version is 0.15.0 (Beta):
We welcome contributions and developers to join us in building this project.
Related MCP server: GeoServer MCP Server
GIS MCP Server empowers AI assistants with advanced geospatial intelligence. Key features include:
🔹 Comprehensive Geometry Operations – Perform intersection, union, buffer, difference, and other geometric transformations with ease.
🔹 Advanced Coordinate Transformations – Effortlessly reproject and transform geometries between coordinate reference systems.
🔹 Accurate Measurements – Compute distances, areas, lengths, and centroids precisely.
🔹 Spatial Analysis & Validation – Validate geometries, run proximity checks, and perform spatial overlays or joins.
🔹 Raster & Vector Support – Process raster layers, compute indices like NDVI, clip, resample, and merge with vector data.
🔹 Spatial Statistics & Modeling – Leverage PySAL for spatial autocorrelation, clustering, and neighborhood analysis.
🔹 Easy Integration – Connect seamlessly with MCP-compatible clients like Claude Desktop or Cursor IDE.
🔹 HTTP/SSE Transport – Run as HTTP service with RESTful storage endpoints for file upload/download operations.
🔹 Flexible Storage – Local filesystem by default, or Google Cloud Storage when you want files in a GCS bucket.
🔹 Flexible & Extensible – Supports Python-based GIS libraries and is ready for custom tools or workflow extensions.
🌟 Tip: With GIS MCP Server, your AI can now “think spatially,” unlocking new capabilities for environmental analysis, mapping, and location intelligence.
GIS MCP Server supports two storage backends for file upload, download, and tool outputs:
Backend | When to use | Configure with |
Local filesystem | Default; files on disk (including Docker volumes) |
|
Google Cloud Storage (GCP) | When you want files in a GCS bucket |
|
Install GCP support with:
pip install gis-mcp[gcp]Full setup (paths, IAM, Docker, credentials): Storage Configuration.
Python 3.10 or higher
MCP-compatible client (like Claude Desktop or Cursor)
Internet connection for package installation
If you’re building agents via vibe coding, give the model these generated maps of GIS MCP:
llms.txt: curated summary for smaller windows.
llms-full.txt: full documentation map for larger windows.
Copies also live in the repository root (llms.txt, llms-full.txt). They are regenerated from the docs during the MkDocs build.
Choose the installation method that best suits your needs:
GIS MCP Server can be run using Docker, which provides an isolated environment with all dependencies pre-installed.
Important: Both Dockerfile and Dockerfile.local have HTTP transport mode enabled by default. The server runs on port 9010 and is accessible at http://localhost:9010/mcp.
The main Dockerfile installs the package from PyPI:
Build the Docker image:
docker build -t gis-mcp .Run the container (HTTP mode is enabled by default):
docker run -p 9010:9010 gis-mcpThe Dockerfile.local installs the package from local source files (useful for development or custom builds):
Build the Docker image:
docker build -f Dockerfile.local -t gis-mcp:local .Run the container (HTTP mode is enabled by default):
docker run -p 9010:9010 gis-mcp:localThe server will be available at http://localhost:9010/mcp in HTTP transport mode.
For more details on Docker configuration and environment variables, see the Docker installation guide.
The pip installation is recommended for most users:
Install uv package manager:
pip install uvCreate the Virtual Environment (Python 3.10+):
uv venv --python=3.10Activate the Virtual Environment:
On Windows (PowerShell):
.\.venv\Scripts\Activate.ps1On Linux:
source .venv/bin/activateInstall the package:
uv pip install gis-mcpTo install with visualization capabilities (Folium and PyDeck for interactive maps):
uv pip install gis-mcp[visualize]This will install additional dependencies:
folium>=0.15.0 - For creating interactive web maps
pydeck>=0.9.0 - For advanced 3D visualizations
Start the server:
gis-mcpBy default, the server runs in STDIO transport mode, which is ideal for local development and integration with Claude Desktop or Cursor IDE.
You can also run the server in HTTP transport mode for network deployments:
export GIS_MCP_TRANSPORT=http
export GIS_MCP_PORT=8080
gis-mcpWhen running in HTTP or SSE transport mode, the following endpoints are available:
MCP endpoint: http://host:port/mcp (HTTP) or http://host:port/sse (SSE)
Storage endpoints:
POST /storage/upload - Upload files to server storage
GET /storage/download?path=<file> - Download files from server storage
GET /storage/list?path=<dir> - List files in server storage
For more details on transport modes and complete endpoint documentation, see:
To use the pip installation with Claude or Cursor, add the following configuration:
Claude Desktop:
Windows:
{
"mcpServers": {
"gis-mcp": {
"command": "C:\\Users\\YourUsername\\.venv\\Scripts\\gis-mcp",
"args": []
}
}
}Linux/Mac:
{
"mcpServers": {
"gis-mcp": {
"command": "/home/YourUsername/.venv/bin/gis-mcp",
"args": []
}
}
}Cursor IDE (create .cursor/mcp.json):
Windows:
{
"mcpServers": {
"gis-mcp": {
"command": "C:\\Users\\YourUsername\\.venv\\Scripts\\gis-mcp",
"args": []
}
}
}Linux/Mac:
{
"mcpServers": {
"gis-mcp": {
"command": "/home/YourUsername/.venv/bin/gis-mcp",
"args": []
}
}
}After configuration:
Make sure to replace YourUsername with your actual username
For development installation, replace /path/to/gis-mcp with the actual path to your project
Restart your IDE to apply the changes
You can now use all GIS operations through Claude or Cursor!
For contributors and developers:
Install uv package manager:
pip install uvCreate the Virtual Environment:
uv venv --python=3.10Install the package in development mode:
uv pip install -e .Start the server:
python -m gis_mcpTo use the development installation with Claude or Cursor, add the following configuration:
Claude Desktop:
Windows:
{
"mcpServers": {
"gis-mcp": {
"command": "C:\\path\\to\\gis-mcp\\.venv\\Scripts\\python",
"args": ["-m", "gis_mcp"]
}
}
}Linux/Mac:
{
"mcpServers": {
"gis-mcp": {
"command": "/path/to/gis-mcp/.venv/bin/python",
"args": ["-m", "gis_mcp"]
}
}
}Cursor IDE (create .cursor/mcp.json):
Windows:
{
"mcpServers": {
"gis-mcp": {
"command": "C:\\path\\to\\gis-mcp\\.venv\\Scripts\\python",
"args": ["-m", "gis_mcp"]
}
}
}Linux/Mac:
{
"mcpServers": {
"gis-mcp": {
"command": "/path/to/gis-mcp/.venv/bin/python",
"args": ["-m", "gis_mcp"]
}
}
}After configuration:
Make sure to replace YourUsername with your actual username
For development installation, replace /path/to/gis-mcp with the actual path to your project
Restart your IDE to apply the changes
You can now use all GIS operations through Claude or Cursor!
Create agents that call real GIS MCP tools (not invented spatial math).
Tutorial: Park buffer proximity agent
Sample: agents/Langchain/
Tutorial: Stateful site-coverage workflow
Sample: agents/LangGraph/
Explicit graph: interpret → plan → execute GIS MCP tools → validate → respond
Verify without an LLM: python agents/LangGraph/verify_graph.py
Tutorial: Multi-agent setback workflow
Planner / Analysis / Validation agents; only Analysis calls GIS MCP
Verify: python agents/LangGraph/verify_multi_agent.py
Minimal starters: templates/ (langchain-gis-agent, langgraph-gis-workflow, langgraph-multi-agent-gis)
Also available: OpenAI Agents SDK (Node.js)
📝 Medium article (LangChain intro) →
This section provides a comprehensive list of all available functions organized by library.
Basic Geometric Operations:
buffer - Create buffer around geometry
intersection - Find intersection of two geometries
union - Combine two geometries
difference - Find difference between geometries
symmetric_difference - Find symmetric difference
Geometric Properties:
convex_hull - Calculate convex hull
envelope - Get bounding box
minimum_rotated_rectangle - Get minimum rotated rectangle
get_centroid - Get centroid point
get_bounds - Get geometry bounds
get_coordinates - Extract coordinate array
get_geometry_type - Get geometry type name
Transformations:
rotate_geometry - Rotate geometry by angle
scale_geometry - Scale geometry by factors
translate_geometry - Move geometry by offset
Advanced Operations:
triangulate_geometry - Create triangulation
voronoi - Create Voronoi diagram
unary_union_geometries - Union multiple geometries
Measurements:
get_length - Calculate geometry length
get_area - Calculate geometry area
Validation & Utilities:
is_valid - Check geometry validity
make_valid - Fix invalid geometry
simplify - Simplify geometry
snap_geometry - Snap to reference geometry
nearest_point_on_geometry - Find nearest point
normalize_geometry - Normalize orientation
geometry_to_geojson - Convert to GeoJSON
geojson_to_geometry - Convert from GeoJSON
Coordinate Transformations:
transform_coordinates - Transform point coordinates
project_geometry - Project geometry between CRS
CRS Information:
get_crs_info - Get detailed CRS information
get_available_crs - List available CRS systems
get_utm_zone - Get UTM zone for coordinates
get_utm_crs - Get UTM CRS for coordinates
get_geocentric_crs - Get geocentric CRS
Geodetic Calculations:
get_geod_info - Get ellipsoid information
calculate_geodetic_distance - Calculate distance on ellipsoid
calculate_geodetic_point - Calculate point at distance/azimuth
calculate_geodetic_area - Calculate area on ellipsoid
I/O Operations:
read_file_gpd - Read geospatial file with preview
write_file_gpd - Export GeoDataFrame to file
Join & Merge Operations:
append_gpd - Concatenate GeoDataFrames vertically
merge_gpd - Database-style attribute joins
overlay_gpd - Spatial overlay operations
dissolve_gpd - Dissolve by attribute
explode_gpd - Split multi-part geometries
Spatial Operations:
clip_vector - Clip geometries
sjoin_gpd - Spatial joins
sjoin_nearest_gpd - Nearest neighbor spatial joins
point_in_polygon - Point-in-polygon tests
Basic Raster Operations:
metadata_raster - Get raster metadata
get_raster_crs - Get raster CRS
extract_band - Extract single band
raster_band_statistics - Calculate band statistics
raster_histogram - Compute pixel histograms
Raster Processing:
clip_raster_with_shapefile - Clip raster with polygons
resample_raster - Resample by scale factor
reproject_raster - Reproject to new CRS
tile_raster - Split into tiles
Raster Analysis:
compute_ndvi - Calculate vegetation index
raster_algebra - Mathematical operations on bands
concat_bands - Combine single-band rasters
weighted_band_sum - Weighted band combination
Advanced Analysis:
zonal_statistics - Statistics within polygons
reclassify_raster - Reclassify pixel values
focal_statistics - Moving window statistics
hillshade - Generate hillshade from DEM
write_raster - Write array to raster file
Spatial Autocorrelation:
morans_i - Global Moran's I statistic
gearys_c - Global Geary's C statistic
gamma_statistic - Gamma index
getis_ord_g - Global Getis-Ord G statistic
Local Statistics:
moran_local - Local Moran's I
getis_ord_g_local - Local Getis-Ord G*
join_counts_local - Local join counts
Global Statistics:
join_counts - Binary join counts test
adbscan - Adaptive density-based clustering
Spatial Weights:
weights_from_shapefile - Create weights from shapefile
distance_band_weights - Distance-based weights
knn_weights - K-nearest neighbors weights
build_transform_and_save_weights - Build, transform, and save weights
ols_with_spatial_diagnostics_safe - OLS regression with spatial diagnostics
build_and_transform_weights - Build and transform weights
Spatial-Temporal Analysis:
spatial_markov - Spatial Markov analysis for panel data
dynamic_lisa - Dynamic LISA (directional LISA) analysis
Spatial Regression:
gm_lag - GM_Lag spatial 2SLS/GMM-IV spatial lag model
Static Map Visualization (Matplotlib/GeoPandas):
create_map – Generate high-quality static maps (PNG, PDF, JPG) from multiple geospatial data sources including shapefiles, rasters, WKT geometries, and coordinate arrays. Supports multiple layers with individual styling options, legends, titles, and grid overlays.
Interactive Web Map Visualization (Folium):
create_web_map – Generate interactive HTML maps using Folium with layer controls, legends, scale bars, dynamic titles, tooltips, and minimap. Supports multiple basemap options and responsive design for web browsers.
Boundary Download:
download_boundaries - Download GADM administrative boundaries and save as GeoJSON
Climate Data Download:
download_climate_data - Download climate data (ERA5 or other CDS datasets)
Ecology Data Download and Info:
get_species_info – Retrieve taxonomic information for a given species name
download_species_occurrences – Download occurrence records for a given species and save as JSON
Movement Data Download and Routing (via OSMnx):
download_street_network – Download a street network for a given place and save as GraphML
calculate_shortest_path – Calculate the shortest path between two points using a saved street network
Land Cover from Planetary Computer:
download_worldcover – Download ESA WorldCover for AOI/year; optional crop and reprojection
compute_s2_ndvi – Compute NDVI from Sentinel-2 L2A; crop and reprojection supported
STAC-based Satellite Download:
download_satellite_imagery – Download and stack bands from STAC items (e.g., Sentinel-2, Landsat), with optional crop and reprojection
Total Functions Available: 92
Example usage of the tools:
Tool: buffer
Parameters: {
"geometry": "POINT(0 0)",
"distance": 10,
"resolution": 16,
"join_style": 1,
"mitre_limit": 5.0,
"single_sided": false
}Tool: transform_coordinates
Parameters: {
"coordinates": [0, 0],
"source_crs": "EPSG:4326",
"target_crs": "EPSG:3857"
}Tool: calculate_geodetic_distance
Parameters: {
"point1": [0, 0],
"point2": [10, 10],
"ellps": "WGS84"
}Tool: create_map
Parameters: {
"layers": [
{
"data": "buildings.shp",
"style": {"label": "Buildings", "color": "red", "alpha": 0.7}
},
{
"data": "roads.shp",
"style": {"label": "Roads", "color": "black", "linewidth": 1}
}
],
"filename": "city_analysis",
"filetype": "png",
"title": "City Infrastructure Analysis",
"show_grid": true,
"add_legend": true
}Tool: create_web_map
Parameters: {
"layers": [
{
"data": "buildings.shp",
"style": {"label": "Buildings", "color": "red"}
},
{
"data": "parks.geojson",
"style": {"label": "Parks", "color": "green"}
}
],
"filename": "city_interactive.html",
"title": "City Infrastructure Map",
"basemap": "CartoDB positron",
"show_grid": true,
"add_legend": true,
"add_minimap": true
}Implement advanced spatial indexing
Implement network analysis capabilities
Add support for 3D geometries
Implement performance optimizations
Add support for more GIS libraries
We welcome contributions! Here's how you can help:
Fork the repository
Create a feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'Add some AmazingFeature')
Push to the branch (git push origin feature/AmazingFeature)
Open a Pull Request
Please ensure your PR description clearly describes the problem and solution. Include the relevant issue number if applicable.
This project is licensed under the MIT License - see the LICENSE file for details.
Project Name | Category | Description |
MCP Related | The core MCP Specification | |
MCP Related | The fast, Pythonic way to build MCP servers and clients | |
Geospatial Analysis | Python package for manipulation and analysis of geometric objects | |
Geospatial Analysis | Python interface to PROJ library | |
Geospatial Analysis | Python package for working with geospatial data | |
Geospatial Analysis | Python package for reading and writing geospatial raster data | |
Geospatial Analysis | Python interface to OGR library for reading and writing vector geospatial data formats | |
Geospatial Analysis | Python spatial analysis library for geospatial data science | |
Visualization | Python library for creating interactive web maps using Leaflet.js | |
Visualization | Python library for creating advanced 3D visualizations and interactive maps | |
Visualization | Python plotting library for creating static maps and visualizations | |
Geospatial Data Collecting | Python API to access the Copernicus Climate Data Store (CDS) | |
Geospatial Data Collecting | Easy access to administrative boundary defined by GADM from Python scripts | |
Geospatial Data Collecting | Python client for the GBIF API (ecology and biodiversity data) | |
Geospatial Data Collecting | Python package for downloading, modeling, and analyzing street networks and urban features from OpenStreetMap | |
Geospatial Data Collecting | Python client for STAC catalogs; search and access spatiotemporal assets | |
Geospatial Data Collecting | Python SDK for Microsoft Planetary Computer; auth and helpers for STAC/COGs |
Server Name | Description |
A Model Context Protocol (MCP) server implementation that connects LLMs to the GeoServer REST API |
For support, please open an issue in the GitHub repository.
Join our Discord community for discussions, updates, and support:
Made with contrib.rocks.
Adaptive DBSCAN clustering (requires coordinates, no dependent_var).
Inputs: shapefile_path (required), dependent_var, target_crs, distance_threshold, +2 more. Returns: object
Reads two shapefiles directly, concatenates them vertically.
Inputs: shapefile1_path (required), shapefile2_path (required), output_path (required). Returns: object
Create a buffer around a geometry.
Inputs: geometry (required), distance (required), resolution, join_style, +2 more. Returns: object
Build and transform spatial weights in one step.
Parameters:
data_path: Path to point shapefile or GeoPackage
method: 'queen', 'rook', 'distance_band', or 'knn'
id_field: Optional field name for IDs
threshold: Distance threshold (required if method='distance_band')
k: Number of neighbors (required if method='knn')
binary: True for binary weights, False for inverse distance (DistanceBand only)
transform_type: 'r', 'v', 'b', 'o', or 'd'
Inputs: data_path (required), method, id_field, threshold, +3 more. Returns: object
Pipeline: Read shapefile, build spatial weights, optionally transform, and save to file.
Parameters:
data_path: Path to point shapefile or GeoPackage
method: 'queen', 'rook', 'distance_band', 'knn'
id_field: Optional field name for IDs
threshold: Distance threshold (required if method='distance_band')
k: Number of neighbors (required if method='knn')
binary: True for binary weights, False for inverse distance (DistanceBand only)
transform_type: 'r', 'v', 'b', 'o', or 'd' (optional)
output_path: File path to save weights
format: 'gal' or 'gwt'
overwrite: Allow overwriting if file exists
Inputs: data_path (required), method, id_field, threshold, +6 more. Returns: object
Calculate area of a polygon using geodetic calculations.
Inputs: geometry (required), ellps. Returns: object
Calculate geodetic distance between points.
Inputs: point1 (required), point2 (required), ellps. Returns: object
Calculate point at given distance and azimuth.
Inputs: start_point (required), azimuth (required), distance (required), ellps. Returns: object
Clip a raster dataset using polygons from a shapefile and write the result. Converts the shapefile's CRS to match the raster's CRS if they are different.
Parameters:
raster_path_or_url: local path or HTTPS URL of the source raster.
shapefile_path: local filesystem path to a .shp file containing polygons.
destination: local path where the masked raster will be written.
Inputs: raster_path_or_url (required), shapefile_path (required), destination (required). Returns: object
Clip vector geometries using geopandas.clip. Args: gdf_path: Path to the input geospatial file. clip_path: Path to the clipping geometry file. output_path: Optional path to save the result. Returns: Dictionary with status, message, and output info.
Inputs: gdf_path (required), clip_path (required), output_path. Returns: object
Compute NDVI (Normalized Difference Vegetation Index) and save to GeoTIFF.
Parameters:
source: input raster path.
red_band_index: index of red band (1-based).
nir_band_index: index of near-infrared band (1-based).
destination: output NDVI raster path.
Inputs: source (required), red_band_index (required), nir_band_index (required), destination (required). Returns: object
Concatenate multiple single-band raster files into one multi-band raster, handling alignment issues automatically.
Parameters:
folder_path: Path to folder containing input raster files (e.g. GeoTIFFs).
destination: Path to output multi-band raster file.
Notes:
Files are read in sorted order by filename.
If rasters have mismatched CRS, resolution, or dimensions, they are aligned automatically.
Inputs: folder_path (required), destination (required). Returns: object
Calculate convex hull of a geometry.
Inputs: geometry (required). Returns: object
Find difference between geometries.
Inputs: geometry1 (required), geometry2 (required). Returns: object
Dissolve geometries by attribute using geopandas.dissolve. Args: gdf_path: Path to the geospatial file. by: Column to dissolve by (optional). output_path: Optional path to save the result. Returns: Dictionary with status, message, and output info.
Inputs: gdf_path (required), by, output_path. Returns: object
Create a distance-based spatial weights (W) object from point data.
data_path: path to point shapefile or GeoPackage
threshold: distance threshold for neighbors (in CRS units, e.g., meters)
binary: True for binary weights, False for inverse distance weights
id_field: optional attribute name to use as observation IDs
Inputs: data_path (required), threshold (required), binary, id_field. Returns: object
Run dynamic LISA (directional LISA) with giddy.directional.Rose.
Returns sector counts, angles, vector lengths, and (optionally) permutation p-values.
Inputs: shapefile_path (required), value_columns (required), target_crs, weights_method, +6 more. Returns: object
Get bounding box of a geometry.
Inputs: geometry (required). Returns: object
Split multi-part geometries into single parts using geopandas.explode. Args: gdf_path: Path to the geospatial file. output_path: Optional path to save the result. Returns: Dictionary with status, message, and output info.
Inputs: gdf_path (required), output_path. Returns: object
Extract a specific band from a multi-band raster and save it as a single-band GeoTIFF.
Parameters:
source: path or URL of the input raster.
band_index: index of the band to extract (1-based).
destination: path to save the extracted band raster.
Inputs: source (required), band_index (required), destination (required). Returns: object
Compute focal (moving window) statistics on a raster. Args: raster_path: Path to the input raster. statistic: Statistic to compute ('mean', 'min', 'max', 'std'). size: Window size (odd integer). output_path: Optional path to save the result. Returns: Dictionary with status, message, and output path if saved.
Inputs: raster_path (required), statistic (required), size, output_path. Returns: object
Compute Gamma Statistic for spatial autocorrelation.
Inputs: shapefile_path (required), dependent_var, target_crs, distance_threshold. Returns: object
Compute Global Geary's C Autocorrelation Statistic.
Inputs: shapefile_path (required), dependent_var, target_crs, distance_threshold. Returns: object
Convert GeoJSON to a Shapely geometry using shapely.geometry.shape. Args: geojson: GeoJSON dictionary. Returns: Dictionary with status, message, and geometry as WKT.
Inputs: geojson (required). Returns: object
Convert a Shapely geometry (WKT) to GeoJSON using shapely.geometry.mapping. Args: geometry: WKT string of the geometry. Returns: Dictionary with status, message, and GeoJSON representation.
Inputs: geometry (required). Returns: object
Get the area of a geometry.
Inputs: geometry (required). Returns: object
Get list of available CRS.
Inputs: no named parameters. Returns: object
Get the bounds of a geometry.
Inputs: geometry (required). Returns: object
Get the centroid of a geometry.
Inputs: geometry (required). Returns: object
Get the coordinates of a geometry.
Inputs: geometry (required). Returns: object
Get information about a CRS.
Inputs: crs (required). Returns: object
Get geocentric CRS for given coordinates.
Inputs: coordinates (required). Returns: object
Get information about a geodetic calculation.
Inputs: ellps, a, b, f. Returns: object
Get the type of a geometry.
Inputs: geometry (required). Returns: object
Compute Getis-Ord G for global hot spot analysis.
Inputs: shapefile_path (required), dependent_var, target_crs, distance_threshold. Returns: object
Local Getis-Ord G.
Inputs: shapefile_path (required), dependent_var, target_crs, distance_threshold. Returns: object
Get the length of a geometry.
Inputs: geometry (required). Returns: object
Retrieve the Coordinate Reference System (CRS) of a raster dataset.
Opens the raster (local path or HTTPS URL), reads its DatasetReader.crs attribute as a PROJ.4-style dict, and also returns the WKT representation.
Inputs: path_or_url (required). Returns: object
Get UTM CRS for given coordinates.
Inputs: coordinates (required). Returns: object
Get UTM zone for given coordinates.
Inputs: coordinates (required). Returns: object
Run spreg.GM_Lag (spatial 2SLS / GMM-IV spatial lag model) on a cross-section.
Returns coefficients with SE/z/p, fit metrics, (optional) AK test, and a small data preview.
Inputs: shapefile_path (required), y_col (required), x_cols (required), target_crs, +11 more. Returns: object
Generate hillshade from a DEM raster. Args: raster_path: Path to the DEM raster. azimuth: Sun azimuth angle in degrees. angle_altitude: Sun altitude angle in degrees. output_path: Optional path to save the hillshade raster. Returns: Dictionary with status, message, and output path if saved.
Inputs: raster_path (required), azimuth, angle_altitude, output_path. Returns: object
Find intersection of two geometries.
Inputs: geometry1 (required), geometry2 (required). Returns: object
Check if a geometry is valid.
Inputs: geometry (required). Returns: object
Global Binary Join Counts.
Inputs: shapefile_path (required), dependent_var, target_crs, distance_threshold. Returns: object
Local Join Counts.
Inputs: shapefile_path (required), dependent_var, target_crs, distance_threshold. Returns: object
Create a k-nearest neighbors spatial weights (W) object from point data.
data_path: path to point shapefile or GeoPackage
k: number of nearest neighbors
id_field: optional attribute name to use as observation IDs
Inputs: data_path (required), k (required), id_field. Returns: object
Make a geometry valid.
Inputs: geometry (required). Returns: object
Merges two shapefiles based on common attribute columns, This function performs a database-style join, not a spatial join. Args: left_shapefile_path: Path to the left shapefile. The geometry from this file is preserved. right_shapefile_path: Path to the right shapefile to merge. output_path: Path to save the merged output shapefile. how: Type of merge. One of 'left', 'right', 'outer', 'inner'. Defaults to 'inner'. on: Column name to join on. Must be found in both shapefiles. left_on: Column name to join on in the left shapefile. right_on: Column name to join on in the right shapefile. suffixes: Suffix to apply to overlapping column names.
Inputs: shapefile1_path (required), shapefile2_path (required), output_path (required). Returns: object
Open a raster dataset in read-only mode and return metadata.
This tool supports two modes based on the provided string:
A local filesystem path (e.g., "D:\Data\my_raster.tif").
An HTTPS URL (e.g., "https://example.com/my_raster.tif").
The input must be a single string that is either a valid file path on the local machine or a valid HTTPS URL pointing to a raster.
Inputs: path_or_url (required). Returns: object
Get minimum rotated rectangle of a geometry.
Inputs: geometry (required). Returns: object
Local Moran's I.
Inputs: shapefile_path (required), dependent_var, target_crs, distance_threshold. Returns: object
Compute Moran's I Global Autocorrelation Statistic.
Inputs: shapefile_path (required), dependent_var, target_crs, distance_threshold. Returns: object
Find the nearest point on geometry2 to geometry1 using shapely.ops.nearest_points. Args: geometry1: WKT string of the first geometry (e.g., a point). geometry2: WKT string of the second geometry. Returns: Dictionary with status, message, and the nearest point as WKT.
Inputs: geometry1 (required), geometry2 (required). Returns: object
Normalize the orientation/order of a geometry using shapely.normalize. Args: geometry: WKT string of the geometry. Returns: Dictionary with status, message, and normalized geometry as WKT.
Inputs: geometry (required). Returns: object
Safe MCP pipeline: Read shapefile, build/load W, convert numeric, check NaNs, run OLS.
Parameters:
data_path: path to shapefile or GeoPackage
y_field: dependent variable column name
x_fields: list of independent variable column names
weights_path: optional path to existing weights file (.gal or .gwt)
weights_method: 'queen', 'rook', 'distance_band', or 'knn' (used if weights_path not provided)
id_field: optional attribute name to use as observation IDs
threshold: required if method='distance_band'
k: required if method='knn'
binary: True for binary weights (DistanceBand only)
Inputs: data_path (required), y_field (required), x_fields (required), weights_path, +5 more. Returns: object
Overlay two GeoDataFrames using geopandas.overlay. Args: gdf1_path: Path to the first geospatial file. gdf2_path: Path to the second geospatial file. how: Overlay method ('intersection', 'union', 'identity', 'symmetric_difference', 'difference'). output_path: Optional path to save the result. Returns: Dictionary with status, message, and output info.
Inputs: gdf1_path (required), gdf2_path (required), how, output_path. Returns: object
Check if points are inside polygons using spatial join (predicate='within'). Args: points_path: Path to the point geospatial file. polygons_path: Path to the polygon geospatial file. output_path: Optional path to save the result. Returns: Dictionary with status, message, and output info.
Inputs: points_path (required), polygons_path (required), output_path. Returns: object
Project a geometry between CRS.
Inputs: geometry (required), source_crs (required), target_crs (required). Returns: object
Perform algebraic operations (addition or subtraction) on two raster bands, handling alignment issues automatically.
Parameters:
raster1: Path to the first raster (.tif).
raster2: Path to the second raster (.tif).
band_index: Index of the band to process (1-based index).
operation: Either "add" or "subtract" to specify the calculation.
destination: Path to save the result as a new raster.
The function aligns rasters if needed, applies the selected operation, and saves the result.
Inputs: raster1 (required), raster2 (required), band_index (required), operation (required), +1 more. Returns: object
Calculate min, max, mean, and std for each band of a raster.
Parameters:
source: path to input raster (local or URL).
Inputs: source (required). Returns: object
Compute histogram of pixel values for each band.
Parameters:
source: path to input raster.
bins: number of histogram bins.
Inputs: source (required), bins. Returns: object
Reads a geospatial file and returns stats and a data preview.
Inputs: file_path (required). Returns: object
Reclassify raster values using a mapping dictionary. Args: raster_path: Path to the input raster. reclass_map: Dictionary mapping old values to new values (e.g., {1: 10, 2: 20}). output_path: Path to save the reclassified raster. Returns: Dictionary with status and message.
Inputs: raster_path (required), reclass_map (required), output_path (required). Returns: object
Reproject a raster dataset to a new CRS and save the result.
Parameters:
source: local path or HTTPS URL of the source raster.
target_crs: target CRS string (e.g., "EPSG:4326").
destination: local filesystem path for the reprojected raster.
resampling: resampling method: "nearest", "bilinear", "cubic", etc.
Inputs: source (required), target_crs (required), destination (required), resampling. Returns: object
Resample a raster dataset by a scale factor and save the result.
Parameters:
source: local path or HTTPS URL of the source raster.
scale_factor: multiplicative factor for width/height (e.g., 0.5 to halve resolution, 2.0 to double).
resampling: resampling method name: "nearest", "bilinear", "cubic", etc.
destination: local filesystem path for the resampled raster.
Inputs: source (required), scale_factor (required), resampling (required), destination (required). Returns: object
Rotate a geometry.
Inputs: geometry (required), angle (required), origin, use_radians. Returns: object
MCP Tool: Save any GIS-MCP result dict to files, only when the user requests.
Args: data: The dictionary returned by any GIS-MCP tool. filename: Base filename without extension. formats: List of formats to save (default = all). folder: Target folder (relative to configured storage directory, or absolute path).
Returns: Dict with 'saved_files' mapping format -> path.
Inputs: data (required), filename, formats, folder. Returns: object
Scale a geometry.
Inputs: geometry (required), xfact (required), yfact (required), origin. Returns: object
Simplify a geometry.
Inputs: geometry (required), tolerance (required), preserve_topology. Returns: object
Spatial join between two GeoDataFrames using geopandas.sjoin. Args: left_path: Path to the left geospatial file. right_path: Path to the right geospatial file. how: Type of join ('left', 'right', 'inner'). predicate: Spatial predicate ('intersects', 'within', 'contains', etc.). output_path: Optional path to save the result. Returns: Dictionary with status, message, and output info.
Inputs: left_path (required), right_path (required), how, predicate, +1 more. Returns: object
Nearest neighbor spatial join using geopandas.sjoin_nearest. Args: left_path: Path to the left geospatial file. right_path: Path to the right geospatial file. how: Type of join ('left', 'right'). max_distance: Optional maximum search distance. output_path: Optional path to save the result. Returns: Dictionary with status, message, and output info.
Inputs: left_path (required), right_path (required), how, max_distance, +1 more. Returns: object
Snap one geometry to another using shapely.ops.snap. Args: geometry1: WKT string of the geometry to be snapped. geometry2: WKT string of the reference geometry. tolerance: Distance tolerance for snapping. Returns: Dictionary with status, message, and snapped geometry as WKT.
Inputs: geometry1 (required), geometry2 (required), tolerance (required). Returns: object
Run giddy Spatial Markov on a panel (n regions x t periods) from a shapefile.
Inputs: shapefile_path (required), value_columns (required), target_crs, weights_method, +8 more. Returns: object
Find symmetric difference between geometries.
Inputs: geometry1 (required), geometry2 (required). Returns: object
Split a raster into square tiles of a given size and save them individually.
Parameters:
source: input raster path.
tile_size: size of each tile (e.g., 256 or 512).
destination_dir: directory to store the tiles.
Inputs: source (required), tile_size (required), destination_dir (required). Returns: object
Transform coordinates between CRS.
Inputs: coordinates (required), source_crs (required), target_crs (required). Returns: object
Translate a geometry.
Inputs: geometry (required), xoff (required), yoff (required), zoff. Returns: object
Create a triangulation of a geometry.
Inputs: geometry (required). Returns: object
Create a union of multiple geometries.
Inputs: geometries (required). Returns: object
Combine two geometries.
Inputs: geometry1 (required), geometry2 (required). Returns: object
Create a Voronoi diagram from points.
Inputs: geometry (required). Returns: object
Compute a weighted sum of all bands in a raster using specified weights.
Parameters:
source: Path to the input multi-band raster file.
weights: List of weights (must match number of bands and sum to 1).
destination: Path to save the output single-band raster.
Inputs: source (required), weights (required), destination (required). Returns: object
Create a spatial weights (W) from a shapefile using contiguity.
contiguity: 'queen' or 'rook' (default 'queen')
id_field: optional attribute name to use as observation IDs
Inputs: shapefile_path (required), contiguity, id_field. Returns: object
Export a GeoDataFrame to a file (Shapefile, GeoJSON, GPKG, etc.). Args: gdf_path: Path to the input geospatial file. output_path: Path to save the exported file. driver: Optional OGR driver name (e.g., 'ESRI Shapefile', 'GeoJSON', 'GPKG'). Returns: Dictionary with status and message.
Inputs: gdf_path (required), output_path (required), driver. Returns: object
Write a numpy array to a raster file using metadata from a reference raster. Args: array: 2D or 3D list (or numpy array) of raster values. reference_raster: Path to a raster whose metadata will be copied. output_path: Path to save the new raster. dtype: Optional data type (e.g., 'float32', 'uint8'). Returns: Dictionary with status and message.
Inputs: array (required), reference_raster (required), output_path (required), dtype. Returns: object
Calculate statistics of raster values within polygons (zonal statistics). Args: raster_path: Path to the raster file. vector_path: Path to the vector file (polygons). stats: List of statistics to compute (e.g., ["mean", "min", "max", "std"]). Returns: Dictionary with status, message, and statistics per polygon.
Inputs: raster_path (required), vector_path (required), stats. Returns: object
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 87 tools
Many tools have overlapping functionality (e.g., union vs unary_union_geometries, merge_gpd vs append_gpd, build_transform_and_save_weights vs build_and_transform_weights, getis_ord_g vs getis_ord_g_local, morans_i vs moran_local). Some tools like 'read_file_gpd' vs 'write_file_gpd' are clearly opposite, but the presence of near-duplicates creates ambiguity.
Naming is inconsistent: some tools use verb_noun (e.g., get_centroid, buffer, union), some include '_gpd' suffix (e.g., merge_gpd, sjoin_gpd), some are camelCase (e.g., morans_i, adbscan), and some are longer descriptive phrases (e.g., build_transform_and_save_weights). No clear pattern emerges across the entire set.
With 87 tools, this far exceeds the typical well-scoped count (3-15). Even for a comprehensive GIS server, this is excessive, and many tools are near-duplicates or could be combined, leading to cognitive overload and increased risk of misselection.
The surface covers an extensive range of vector, raster, and spatial statistics operations, including CRUD-like file operations, geometry analysis, raster processing, and spatial autocorrelation. Minor gaps exist (e.g., no explicit raster classification or network analysis), but the domain is well-covered overall.
Geospatial AI MCP server — satellite imagery, embeddings, weather, GNS governance
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
MCP server for Japan geodata: cadastral lot numbers (chiban) and reverse geocoding, for AI agents.
The Google Maps MCP server is a fully-managed server provided by the Maps Grounding Lite API that connects AI applications to Google Maps Platform services. It provides three main tools for building LLM applications: searching for places, looking up weather information, and computing routes with details like distance and travel time. The server acts as a proxy that translates Google Maps data into a format that AI applications can understand, enabling agents to accurately answer real-world location and travel queries.