ArcGIS Location Services MCP Server
Provides tools for geocoding, reverse geocoding, finding nearby places, getting directions, elevation data, and accessing basemap tiles through ArcGIS Location Services.
Provides integration with ArcGIS Location Services by Esri, enabling geospatial data operations such as geocoding, directions, and elevation queries.
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., "@ArcGIS Location Services MCP Servergeocode the address 1 Infinite Loop, Cupertino, CA"
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.
ArcGIS Location Services MCP Server
MCP Server for ArcGIS Location Services.
Tools
geocodeSearch for an address, place, or point of interest
Inputs:
singleLine(string): Complete address in a single stringaddress(string): Place name or partial addresslocation(string, optional): Nearby point in "longitude,latitude" formatcategory(string, optional): POI category to search for
Returns: Matching locations with addresses, coordinates, and match scores
reverse_geocodeConvert geographic coordinates to an address
Inputs:
location(string): Location as "longitude,latitude"outFields(string, optional): Fields to include in response
Returns: Address information, location type, and address components
find_nearby_placesFind nearby places and points of interest
Inputs:
x(number): Longitude of center pointy(number): Latitude of center pointpageSize(number, optional): Number of results to returncategories(string, optional): Category filterradius(number, optional): Search radius in metersincludeDetails(boolean, optional): Whether to include detailed place informationdetailsLimit(number, optional): Maximum number of places to get details for
Returns: List of places with names, addresses, categories, and optional details
get_directionsGet detailed turn-by-turn directions between locations
Input:
stops(string): Semicolon-separated list of "longitude,latitude" pairs
Returns: Route summary with distance, time, and turn-by-turn directions
get_elevationGet elevation data for locations on land or water
Inputs:
lonandlat(numbers, optional): Coordinates for a single pointcoordinates(string, optional): JSON array of [lon, lat] pairs for multiple pointsrelativeTo(string, optional): Reference point for elevation measurement
Returns: Elevation data with reference datum and spatial reference
get_basemap_tileAccess static basemap tiles service with different styles
Inputs:
version(string, optional): API versionstyle_base(string, optional): Base style categorystyle_name(string, optional): Map style namerow,level,column(numbers, optional): Tile coordinates
Returns: Basemap tile information and status
Related MCP server: mcp-opencages
Setup
Installing via Smithery
To install arcgis-location-services-mcp for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install @puran1218/arcgis-location-services-mcp --client claudeAPI Key
Get an ArcGIS Developer API key by creating an account at ArcGIS Location Platform and generating an API key.
Usage with Claude Desktop
Add the following to your claude_desktop_config.json in Claude for Desktop:
{
"mcpServers": {
"arcgis-location-services": {
"command": "uv",
"args": [
"--directory",
"C:\\ABSOLUTE\\PATH\\TO\\ArcGIS-Location-Services-MCP-Server",
"run",
"main.py"
],
"env": {
"ARCGIS_LOCATION_SERVICE_API_KEY": "<YOUR_API_KEY>"
}
}
}
}License
This MCP server is provided as-is. Usage of ArcGIS Location Services is subject to Esri's terms of service.
Available Tools
6 toolsfind_nearby_placesB
Find nearby places and points of interest with optional detailed information.
Args:
x: Longitude of the center point (e.g., -122.4194)
y: Latitude of the center point (e.g., 37.7749)
pageSize: Number of results to return (default: 20)
categories: Optional category filter (e.g., "restaurant", "hotel", "coffee")
radius: Search radius in meters (default: 5000)
includeDetails: Whether to include full details for each place (default: False)
detailsLimit: Maximum number of places to get details for when includeDetails=True (default: 3)
| Name | Required | Description | Default |
|---|---|---|---|
| x | Yes | ||
| y | Yes | ||
| radius | No | ||
| pageSize | No | ||
| categories | No | ||
| detailsLimit | No | ||
| includeDetails | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description should fully disclose behavior. It implies read-only but doesn't state non-destructiveness. Missing details on API behavior, errors, or side effects. Minimal transparency beyond parameter list.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is well-structured with parameter listing and defaults, but the list format is verbose. Could be more concise by grouping defaults. Still clear and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema or description of return format. Lacks details on pagination, error handling, or what detail information contains. Adequate for basic understanding but incomplete for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds examples and explanations for parameters (e.g., 'Longitude of the center point'), which are absent from the schema. Defaults differ between description and schema (e.g., pageSize: 20 vs 10), which slightly reduces clarity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool finds nearby places and points of interest with optional details. It distinguishes from sibling tools like geocode or directions by focusing on 'nearby' search, but does not explicitly contrast usage.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., geocode for address lookup). No mention of when to set includeDetails or limitations like rate limits. The description is purely declarative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
geocodeB
Search for an address, place or point of interest.
Args:
singleLine: Complete address in a single string (e.g., "1600 Pennsylvania Ave NW, DC")
address: Place name or address (e.g., "Starbucks" or "380 New York St")
location: Optional point to search near, as "longitude,latitude" (e.g., "-122.4194,37.7749")
category: Optional POI category to search for (e.g., "gas station")
outFields: Fields to return in the response (default: all fields)
| Name | Required | Description | Default |
|---|---|---|---|
| address | No | ||
| category | No | ||
| location | No | ||
| outFields | No | * | |
| singleLine | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so the description must disclose behaviors. It describes parameters but omits side effects, rate limits, or whether the tool is read-only. A read-only hint would improve transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose sentence followed by an Args list. It is somewhat verbose but each part is relevant; no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers all parameters but lacks details on return values or behavior. Without an output schema, the description should hint at the response format (e.g., coordinates). Adequate but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates by explaining all 5 parameters, including purpose and format (e.g., location as 'longitude,latitude'). This adds clear value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches for addresses, places, or points of interest, which distinguishes forward geocoding from reverse_geocode. However, it does not explicitly differentiate from find_nearby_places.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus siblings like reverse_geocode or find_nearby_places. The description provides parameter details but lacks context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_basemap_tileB
Access static basemap tiles service with different styles.
Args:
version: API version (default: v1)
style_base: The base style category (default: arcgis)
style_name: Map style name (e.g., navigation, streets, satellite)
row: Tile row coordinate
level: Zoom level
column: Tile column coordinate
| Name | Required | Description | Default |
|---|---|---|---|
| row | No | ||
| level | No | ||
| column | No | ||
| version | No | v1 | |
| style_base | No | arcgis | |
| style_name | No | navigation |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full behavioral burden. It does not disclose output format (image? URL?), error behavior, rate limits, or authentication requirements. Only a minimal list of parameters is provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is concise and structured as an Args list, making it easy to scan. The first sentence conveys the core purpose. It could benefit from more front-loading, but overall efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 6 parameters, no output schema, and no annotations, the description is incomplete. It omits return value details, error handling, and usage context, which is necessary for a tool with moderate complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so description must compensate. It provides one-line explanations for each parameter (e.g., 'style_name: Map style name (e.g., navigation, streets, satellite)'), which adds meaning but lacks detail on accepted values or formats.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it accesses a static basemap tiles service with different styles. It distinguishes well from sibling tools like geocode or find_nearby_places, which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. The description only says what it does, not when it should be chosen over siblings like get_elevation or get_directions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_directionsA
Get detailed turn-by-turn directions between locations.
Args:
stops: Two or more locations as a semicolon-separated list of "longitude,latitude" pairs
(e.g., "-122.68782,45.51238;-122.690176,45.522054")
| Name | Required | Description | Default |
|---|---|---|---|
| stops | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes the input format and that output is turn-by-turn directions, but does not disclose output structure, limitations, or potential errors. Adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—one line plus an args docstring. Every sentence adds value, and the key information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple tool (1 parameter, no output schema, no annotations), the description is complete enough for an agent to understand the tool's purpose and how to format the input. It could mention return format but overall suffices.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description adds significant meaning: it explains that 'stops' must be two or more locations as semicolon-separated longitude,latitude pairs. This clarifies the format and constraint beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get detailed turn-by-turn directions between locations.' This is a specific verb+resource combination that distinguishes the tool from siblings like geocode or get_elevation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when turn-by-turn directions are needed, but provides no guidance on when not to use it or which sibling tools might be alternatives. No explicit context or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_elevationA
Get elevation for locations on land or water.
Args:
lon: Longitude of a single point (e.g., -117.195)
lat: Latitude of a single point (e.g., 34.065)
coordinates: JSON array of [lon, lat] pairs for multiple points (e.g., "[[-117.182, 34.0555],[-117.185, 34.057]]")
relativeTo: Reference point for elevation measurement (e.g., "meanSeaLevel", "ellipsoid")
| Name | Required | Description | Default |
|---|---|---|---|
| lat | No | ||
| lon | No | ||
| relativeTo | No | ||
| coordinates | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explains the parameters and their formats but does not disclose behavioral traits such as rate limits, authentication requirements, or handling of invalid inputs. Without annotations, it partially meets transparency needs but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, with a clear purpose statement followed by bulleted parameter descriptions. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description thoroughly covers parameter semantics but lacks information about return values (no output schema) and constraints (e.g., valid coordinate ranges, maximum coordinate count). This leaves gaps for an agent to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by providing detailed explanations, examples, and types for each parameter (lon, lat, coordinates, relativeTo), adding significant meaning beyond the schema structure.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get elevation for locations on land or water,' using a specific verb and resource. It distinguishes itself from sibling tools like geocode or get_basemap_tile, which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives. It does not specify conditions, prerequisites, or when not to use it, leaving the agent with only implicit context from sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
reverse_geocodeA
Convert geographic coordinates to an address.
Args:
location: Location as "longitude,latitude" (e.g., "-79.3871,43.6426")
outFields: Fields to include in the response (default: all fields)
| Name | Required | Description | Default |
|---|---|---|---|
| location | Yes | ||
| outFields | No | * |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only explains parameter format but omits details like error handling, rate limits, or output structure (e.g., address format). Fails to provide sufficient transparency beyond basic functionality.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with a clear purpose statement and parameter documentation. No wasted words; every sentence adds value. Front-loaded with action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter tool with no output schema or annotations, the description is adequate but incomplete. It could describe expected output format, coordinate bounds, or error behavior to fully inform usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but description adds meaning: location format as 'longitude,latitude' with example, and outFields as 'Fields to include in the response' with default all. This significantly clarifies parameter usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Convert geographic coordinates to an address,' specifying the verb and resource. It implicitly distinguishes from sibling 'geocode' which does the reverse operation. This is specific and informative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the tool's purpose: use when you have coordinates and need an address. No explicit when-to-use or when-not statements, nor reference to alternatives like 'geocode'. Lacks clear guidance for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v0.1.0- First observed
find_nearby_places - First observed
geocode - First observed
get_basemap_tile - First observed
get_directions - First observed
get_elevation - First observed
reverse_geocode
TDQS
Scored across 6 tools
Each tool has a distinct purpose: basemap tiles, nearby places, geocoding, reverse geocoding, directions, and elevation. No overlap in functionality.
All tool names follow a consistent verb_noun pattern in snake_case, such as get_basemap_tile, find_nearby_places, geocode, reverse_geocode, get_directions, get_elevation. The naming is clear and predictable.
With 6 tools, the server covers essential location services without being sparse or overwhelming. Each tool serves a specific function, and the count is well-scoped for the domain.
The tool set includes core GIS operations: tile access, POI search, geocoding, reverse geocoding, directions, and elevation. Minor gaps exist, such as missing batch geocoding or spatial queries, but the surface is reasonably complete for a basic location services server.
Maintenance
Related MCP Connectors
Geocoding, reverse geocoding, and places search for LatLng.
Geocode, reverse geocode, and run Overpass spatial queries on OpenStreetMap data.
Geocode, reverse geocode, and run Overpass spatial queries on OpenStreetMap data.
Geocoding, weather forecasts, and timezone lookups
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables geocoding and reverse geocoding from OpenStreetMap data using the free Nominatim API.4 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables forward and reverse geocoding using the OpenCage API, allowing conversion between addresses and coordinates.2 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables geocoding, reverse geocoding, elevation profiles, static map PNGs, and coordinate reprojection using MapTiler's OpenStreetMap data.1 npmMIT
- AlicenseAqualityBmaintenanceProvides location-based services and geospatial data from OpenStreetMap, enabling geocoding, route directions, nearby place search, and neighborhood analysis through natural language.12MIT