Google Maps MCP Server
Provides comprehensive access to Google Maps Platform APIs, enabling geocoding, places search, routing, geolocation, and other geospatial operations.
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., "@Google Maps MCP Serverfind Italian restaurants near Times Square"
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.
Google Maps MCP Server
A Model Context Protocol (MCP) server that provides comprehensive access to Google Maps Platform APIs. This server enables LLMs to perform geocoding, places search, routing, and other geospatial operations through a standardized interface.
Features
πΊοΈ Comprehensive Google Maps Integration - Access to Places, Routes, Geocoding, and utility APIs
π Advanced Places Search - Text search, nearby search, autocomplete, and detailed place information
π£οΈ Smart Routing - Route computation with real-time traffic, tolls, and alternative routes
π Precise Geocoding - Forward and reverse geocoding with international support
π Geolocation Services - IP-based and WiFi/cellular location estimation
π Rich Resources - Built-in documentation and examples accessible via MCP resources
π Security First - Input validation, rate limiting, and secure API key handling
Related MCP server: MCP Google Maps
Quick Start
1. Get Google Maps API Key
Visit the Google Cloud Console
Create a new project or select an existing one
Enable the required APIs (see API requirements by tool below)
Create an API key and restrict it to the enabled APIs
Important: This server uses the new Google Maps Platform APIs (Places API (New) and Routes API), not the legacy versions
API Requirements by Tool
Tool | Required Google Cloud Console API |
| Geocoding API |
| Places API (New) |
| Routes API |
| Elevation API |
| Time Zone API |
| Geolocation API |
| Roads API |
| Geolocation API + Places API (New) |
2. Configure MCP Client
Add the server to your MCP client configuration:
Cursor
Add to your Cursor MCP settings (~/.cursor/mcp.json or through Command Palette > Open MCP Settings > New MCP Server):
{
"mcpServers": {
"google-maps": {
"command": "npx",
"args": ["-y", "google-maps-mcp-server"],
"env": {
"GOOGLE_MAPS_API_KEY": "your-api-key-here"
}
}
}
}With custom rate limiting:
{
"mcpServers": {
"google-maps": {
"command": "npx",
"args": ["-y", "google-maps-mcp-server"],
"env": {
"GOOGLE_MAPS_API_KEY": "your-api-key-here",
"GOOGLE_MAPS_RATE_LIMIT_ENABLED": "true",
"GOOGLE_MAPS_RATE_LIMIT_WINDOW_MS": "120000",
"GOOGLE_MAPS_RATE_LIMIT_MAX_REQUESTS": "200"
}
}
}
}Claude Desktop
Add to claude_desktop_config.json:
{
"mcpServers": {
"google-maps": {
"command": "npx",
"args": ["google-maps-mcp-server"],
"env": {
"GOOGLE_MAPS_API_KEY": "your-api-key-here"
}
}
}
}With rate limiting disabled:
{
"mcpServers": {
"google-maps": {
"command": "npx",
"args": ["google-maps-mcp-server"],
"env": {
"GOOGLE_MAPS_API_KEY": "your-api-key-here",
"GOOGLE_MAPS_RATE_LIMIT_ENABLED": "false"
}
}
}
}Other MCP Clients
# Set environment variable
export GOOGLE_MAPS_API_KEY="your-api-key-here"
# Run the server
npx google-maps-mcp-serverAvailable Tools
Geocoding
geocode_search- Convert addresses to coordinatesgeocode_reverse- Convert coordinates to addresses
Places
places_search_text- Search places with natural languageplaces_nearby- Find places within a radiusplaces_autocomplete- Get place suggestionsplaces_details- Get detailed place informationplaces_photos- Get place photo URLs
Routing
routes_compute- Calculate optimal routesroutes_matrix- Compute distance matrices
Utilities
elevation_get- Get elevation datatimezone_get- Get timezone informationgeolocation_estimate- Estimate location from WiFi/cell dataroads_nearest- Find nearest roads
Special Tools
nearby_find- Find nearby cities, towns, or POIsip_geolocate- Geolocate using IP address
Usage Examples
Find Nearby Restaurants
{
"tool": "places_nearby",
"arguments": {
"location": {"lat": 37.7749, "lng": -122.4194},
"radius_meters": 1000,
"included_types": ["restaurant"],
"max_results": 10
}
}Get Driving Directions
{
"tool": "routes_compute",
"arguments": {
"origin": {"address": "San Francisco, CA"},
"destination": {"address": "Los Angeles, CA"},
"travel_mode": "DRIVE",
"routing_preference": "TRAFFIC_AWARE"
}
}Geocode an Address
{
"tool": "geocode_search",
"arguments": {
"query": "1600 Amphitheatre Parkway, Mountain View, CA",
"language": "en"
}
}Geolocate by IP Address
{
"tool": "ip_geolocate",
"arguments": {
"reverse_geocode": true
}
}The ip_geolocate tool also supports an optional ip_override parameter for testing with different IP addresses:
{
"tool": "ip_geolocate",
"arguments": {
"ip_override": "8.8.8.8",
"reverse_geocode": true
}
}Note: The ip_override parameter accepts public IPv4 or IPv6 addresses. Private and reserved IP ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 127.0.0.0/8) are rejected. The IP override is best-effort and Google's Geolocation API may not always honor the request.
Configuration
Environment Variables
GOOGLE_MAPS_API_KEY(required) - Your Google Maps Platform API key
Rate Limiting Configuration
GOOGLE_MAPS_RATE_LIMIT_ENABLED(optional, default:true) - Enable/disable rate limitingSet to
falseto disable rate limiting entirely
GOOGLE_MAPS_RATE_LIMIT_WINDOW_MS(optional, default:60000) - Rate limit window in millisecondsControls the time window for rate limiting (e.g., 60000 = 1 minute)
GOOGLE_MAPS_RATE_LIMIT_MAX_REQUESTS(optional, default:100) - Maximum requests per windowMaximum number of requests allowed per endpoint within the time window
Example Rate Limiting Configurations
# Default rate limiting (100 requests per minute per endpoint)
GOOGLE_MAPS_API_KEY="your-api-key-here"
# Disable rate limiting entirely
GOOGLE_MAPS_API_KEY="your-api-key-here"
GOOGLE_MAPS_RATE_LIMIT_ENABLED=false
# Custom rate limiting (200 requests per 2 minutes per endpoint)
GOOGLE_MAPS_API_KEY="your-api-key-here"
GOOGLE_MAPS_RATE_LIMIT_WINDOW_MS=120000
GOOGLE_MAPS_RATE_LIMIT_MAX_REQUESTS=200
# Stricter rate limiting (50 requests per 30 seconds per endpoint)
GOOGLE_MAPS_API_KEY="your-api-key-here"
GOOGLE_MAPS_RATE_LIMIT_WINDOW_MS=30000
GOOGLE_MAPS_RATE_LIMIT_MAX_REQUESTS=50API Quotas and Billing
This server uses Google Maps Platform APIs which require billing to be enabled. Monitor your usage in the Google Cloud Console to avoid unexpected charges. Consider implementing usage limits in your application.
Resources
The server provides built-in MCP resources with documentation and examples:
google-maps://docs/api-overview- API overview and capabilitiesgoogle-maps://docs/place-types- Complete place types referencegoogle-maps://docs/travel-modes- Available travel modesgoogle-maps://docs/field-masks- Places API field optimizationgoogle-maps://examples/common-queries- Example queries and patterns
Access these through your MCP client's resource interface.
Development
Building from Source
git clone <repository-url>
cd google-maps-mcp-server
npm install
npm run buildTesting
npm testUsing MCP Inspector
npm run build
GOOGLE_MAPS_API_KEY="your-api-key-here" npx @modelcontextprotocol/inspector ./dist/index.jsError Handling
The server returns structured errors with helpful context:
{
"error": {
"code": "QUOTA_EXCEEDED",
"message": "API quota exceeded",
"context": {
"endpoint": "/places/textsearch",
"status": 429
}
}
}Common error codes:
INVALID_REQUEST- Invalid input parametersAPI_KEY_INVALID- Invalid or missing API keyQUOTA_EXCEEDED- API quota exceededREQUEST_FAILED- Network or API request failed
Security
API keys are never logged or exposed
Input validation prevents injection attacks
Rate limiting protects against abuse
IP addresses are hashed in logs for privacy
Contributing
Contributions are welcome! Please submit pull requests to our GitHub repository.
License
MIT License - see LICENSE file for details.
Available Tools
15 toolselevation_getB
Get elevation data for locations or along a path
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | Encoded polyline path for elevation sampling. Use Google's polyline encoding format | |
| samples | No | Number of samples along path | |
| locations | No | Array of coordinates to get elevation data for |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits such as data units, limits, or rate constraints. It only states the basic function.
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 a single sentence, concise and front-loaded. It efficiently communicates the core purpose without unnecessary words.
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 no output schema and simple param set, the description is adequate but lacks details on return format or usage constraints. It meets minimum viability.
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?
The input schema has 100% description coverage, so baseline is 3. The tool description does not add additional meaning beyond what the schema already provides for each parameter.
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 retrieves elevation data for locations or along a path. This purpose is distinct from sibling tools like geocoding or routing.
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 implies usage for elevation queries, but lacks exclusions or context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
geocode_reverseB
Convert geographic coordinates (latitude/longitude) into human-readable addresses with detailed address components. Useful for location-based services and mapping applications.
| Name | Required | Description | Default |
|---|---|---|---|
| lat | Yes | Latitude | |
| lng | Yes | Longitude | |
| language | No | Language code for results (ISO 639-1, e.g., "en", "es", "fr") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'detailed address components' but does not specify what components, limitations, or behavioral traits like accuracy, rate limits, or required permissions.
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 short at two sentences, with the first sentence clearly stating the function. The second sentence is somewhat generic but not excessive. Could be more concise by removing redundant 'useful for' phrase.
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 tool has low complexity with 3 parameters and no output schema. The description adequately states the core function but lacks details on return format and address components. Sibling tools offer richer functionality, but this description is minimally sufficient.
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 100%, so baseline is 3. The description does not add additional meaning beyond the schema; it does not elaborate on parameter formats, defaults, or constraints.
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 converts coordinates to addresses, which is reverse geocoding. It uses specific verb 'Convert' and resource 'coordinates into addresses', distinguishing it from forward geocoding (geocode_search) among siblings.
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 mentions 'Useful for location-based services and mapping applications', which implies context but does not explicitly state when to use this versus alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
geocode_searchA
Convert addresses, place names, or landmarks into geographic coordinates (latitude/longitude). Supports region biasing and multiple languages for accurate global geocoding.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Address or place name to geocode. Examples: "1600 Amphitheatre Parkway, Mountain View, CA", "Eiffel Tower", "Tokyo, Japan" | |
| region | No | Region code for biasing results (ISO 3166-1 alpha-2, e.g., "US", "GB", "DE") | |
| language | No | Language code for results (ISO 639-1, e.g., "en", "es", "fr") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It implies a read-only conversion, but does not disclose rate limits, authentication needs, or any specific behavioral traits beyond the basic operation.
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?
Two sentences, concise and front-loaded with the primary action. No unnecessary words.
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?
Adequately covers purpose and key features (region, language). Does not explain output format (latitude/longitude likely) or whether multiple results are returned, but given the simplicity of the tool, it is reasonably 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?
Schema coverage is 100% with descriptions for all parameters. Description adds minimal extra meaning beyond summarizing the support for region and language biasing. Examples in query schema are helpful but redundant.
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 converts addresses/place names/landmarks into geographic coordinates. Distinct from sibling 'geocode_reverse' which does the opposite.
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?
Mentions region biasing and multiple languages for accurate global geocoding, indicating appropriate use cases. Lacks explicit when-not-to-use or comparisons to other geolocation tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
geolocation_estimateB
Estimate location from WiFi/cell data using Google Geolocation API
| Name | Required | Description | Default |
|---|---|---|---|
| cell_towers | No | Array of cell towers detected by the device | |
| consider_ip | No | Whether to use IP address for location estimation | |
| wifi_access_points | No | Array of WiFi access points detected by the device |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It only says 'estimate location' but fails to mention rate limits, accuracy, required permissions, response format, or behavior with insufficient data.
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 a single concise sentence that front-loads the purpose. It avoids fluff, though it could be expanded slightly to cover usage without losing conciseness.
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 tool's complexity (3 parameters, no required fields, no output schema), the description is incomplete. It doesn't explain return values, error handling, or how to structure the input. The absence of output schema further burdens the description, which fails to compensate.
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 description coverage is 100%, so each parameter already has a description. The tool description adds no additional meaning beyond the schema, meeting the baseline expectation but not exceeding it.
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's purpose: estimating location from WiFi and cell data using the Google Geolocation API. It specifies the verb 'estimate', the resource 'location', and the data sources, distinguishing it from siblings like ip_geolocate which uses IP data.
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 guidance on when to use this tool versus alternatives such as ip_geolocate for IP-based location or geocode_reverse for address-to-coordinates. It does not specify prerequisites, limitations, or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ip_geolocateA
Estimate geographic location using IP address through Google's Geolocation API. Provides approximate location with accuracy radius and optional reverse geocoding for address details.
| Name | Required | Description | Default |
|---|---|---|---|
| language | No | Language code for the reverse geocoded address (ISO 639-1, e.g., "en", "es", "fr"). Only used when reverse_geocode is true | |
| ip_override | No | Optional IP address to override for testing (best-effort) | |
| reverse_geocode | No | Whether to reverse geocode the result |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description mentions approximate location and accuracy radius but lacks critical behavioral details such as rate limits, authentication requirements, or error handling for invalid IPs. With no annotations, the description should provide more 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?
Two concise sentences front-load the core purpose and add a key detail about reverse geocoding with no wasted words.
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?
While parameter descriptions are complete, the description omits output structure and error scenarios. Given no output schema, a brief mention of return fields would improve completeness.
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 covers all three parameters with descriptions, and the tool's description adds context for 'reverse_geocode' and 'language' by linking them to the optional reverse geocoding feature, enhancing understanding beyond 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?
Description clearly states the tool estimates geographic location from an IP address via Google's Geolocation API, distinguishing it from sibling tools like geolocation_estimate which may use other methods.
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 like geocode_reverse or geolocation_estimate. Agent must infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
nearby_findA
Discover nearby cities, towns, or points of interest from any location or address. Automatically calculates distances and sorts results by proximity. Supports both coordinate and address-based searches.
| Name | Required | Description | Default |
|---|---|---|---|
| what | Yes | Type of places to search for: "cities" for major cities, "towns" for smaller localities, "pois" for points of interest, "custom" for specific types via included_types | |
| origin | Yes | Starting location for the search. Provide either coordinates like {"lat": 37.7749, "lng": -122.4194} or an address like {"address": "San Francisco, CA"} | |
| region | No | Region code for biasing results (ISO 3166-1 alpha-2, e.g., "US", "GB", "DE") | |
| language | No | Language code for results (ISO 639-1, e.g., "en", "es", "fr") | |
| max_results | No | Maximum number of results to return (default: 20) | |
| radius_meters | No | Search radius in meters (default: 30000) | |
| included_types | No | Specific place types to include (used with what=custom or pois). Example: ["restaurant", "gas_station", "tourist_attraction"] |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that distances are automatically calculated and results sorted by proximity, but does not mention rate limits, authentication, or output format. For a read tool, this is adequate but could be more transparent.
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 two sentences, clear and to the point. Every sentence adds value: first sentence states the action, second sentence adds behavioral detail. No unnecessary words.
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 is provided, so the description should hint at the return format. It does not mention what is returned (e.g., list of places with distances and coordinates). Also lacks pagination details despite a max_results parameter. 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?
Schema description coverage is 100%, so the schema already documents all parameters. The description adds no new parameter-level information beyond what is in the schema. The baseline of 3 is appropriate.
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 discovers nearby cities, towns, or points of interest, and specifies it supports coordinate and address-based searches. It distinguishes from siblings by focusing on general nearby discovery with automatic distance calculation and sorting.
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 for finding nearby places but does not provide guidance on when to use this tool versus alternatives like 'places_nearby' or 'places_search_text'. No explicit when-to-use or when-not-to-use information is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
places_autocompleteC
Get place suggestions for autocomplete
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Input text for autocomplete suggestions. Examples: "pizza", "123 Main", "Eiffel Tow" | |
| region | No | Region code for biasing results (ISO 3166-1 alpha-2, e.g., "US", "GB", "DE") | |
| language | No | Language code for results (ISO 639-1, e.g., "en", "es", "fr") | |
| location_bias | No | Geographic region to bias search results toward | |
| session_token | No | Session token for billing | |
| included_types | No | Place types to include in suggestions |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as whether the tool is read-only, authentication requirements, or rate limits. The schema mentions a 'session_token' for billing, but this is in the schema, not the description. The description adds no behavioral context beyond the function name.
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 a single sentence, front-loaded with the verb. It is concise but could benefit from additional context without becoming verbose. No filler.
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 including nested objects, no output schema, and the tool's role in a location autocomplete flow, the description is insufficient. It does not explain how parameters like 'region' and 'location_bias' interact, nor what the tool returns (e.g., place predictions with IDs). The description lacks completeness for effective agent 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?
All 6 parameters have descriptions in the schema (100% coverage), so the description need not add param details. However, the description does not list or summarize the parameters, providing no additional meaning beyond what the schema already offers. Baseline score of 3 is appropriate.
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 states the tool's purpose clearly: 'Get place suggestions for autocomplete'. It uses a specific verb ('Get') and resource ('place suggestions'), differentiating it from sibling tools like 'places_search_text' which performs full text searches.
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 guidance on when to use this tool versus alternatives like 'places_search_text' or 'places_nearby'. No exclusions or conditions are mentioned, leaving the agent to infer context from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
places_detailsC
Get detailed information about a place
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | Specific fields to return from place details. Examples: ["name", "formatted_address", "opening_hours", "rating", "reviews"] | |
| region | No | Region code for biasing results (ISO 3166-1 alpha-2, e.g., "US", "GB", "DE") | |
| language | No | Language code for results (ISO 639-1, e.g., "en", "es", "fr") | |
| place_id | Yes | Place ID | |
| session_token | No | Session token for billing (optional) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description should disclose behavioral traits. It only says 'Get detailed information' without mentioning authorization, rate limits, errors, or what happens with invalid place IDs.
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 a single sentence but is too brief, omitting critical details. It does not earn its place as it provides minimal value beyond the title.
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?
With no output schema and no annotations, the description should be richer. It fails to explain return format, error handling, or usage context, making it incomplete.
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 100% and each parameter has a description. The description adds no further context beyond what the schema already provides, so baseline 3 is appropriate.
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 'Get detailed information about a place' is clear and specific, using a verb and resource. It distinguishes well from sibling tools like 'places_nearby' or 'places_autocomplete'.
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. For example, it does not mention that for simple existence checks or lists, other tools are more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
places_nearbyC
Discover places within a specified radius of a geographic location. Perfect for finding restaurants, shops, services, and attractions near a specific point of interest.
| Name | Required | Description | Default |
|---|---|---|---|
| region | No | Region code for biasing results (ISO 3166-1 alpha-2, e.g., "US", "GB", "DE") | |
| language | No | Language code for results (ISO 639-1, e.g., "en", "es", "fr") | |
| location | Yes | Geographic coordinates of the center point for the search. Provide as {"lat": 37.7749, "lng": -122.4194} | |
| max_results | No | Maximum number of results to return | |
| radius_meters | Yes | Search radius in meters | |
| included_types | No | Place types to include in search |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behaviors (e.g., read-only, rate limits, output format). It only advertises features without mentioning any constraints or return characteristics, leaving critical gaps for an agent.
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?
Two sentences efficiently convey purpose and typical use cases. No extraneous text; each sentence earns its place. Front-loaded with the core 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?
The description omits what the tool returns (e.g., place details, ratings). Without an output schema, this is a significant gap. For a common task like nearby search, more context on results and limitations is needed.
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?
All parameters have full schema descriptions, so the description adds limited value. It provides context ('restaurants, shops...') but doesn't specify parameter formats or interdependencies beyond what's already in 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 discovers places within a radius, with examples like restaurants and shops. However, it does not differentiate it from similar sibling tools like 'nearby_find' or 'places_search_text', missing an opportunity to clarify unique scope.
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. The description mentions it's 'perfect for finding...' but lacks explicit when-to-use or when-not-to-use conditions, which is problematic given multiple related sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
places_photosC
Get signed photo URLs for a place
| Name | Required | Description | Default |
|---|---|---|---|
| max_width | No | Maximum width in pixels | |
| max_height | No | Maximum height in pixels | |
| photo_reference | Yes | Photo reference from place details |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description does not disclose any behavioral traits beyond the basic action. Missing details like authentication requirements, rate limits, or whether the URLs expire.
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?
Single sentence with no unnecessary words. Efficiently communicates the tool's purpose.
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 no output schema and no annotations, the description is too minimal. It does not explain the return value (URLs), potential errors, or how to properly use the parameters together.
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 100%, so the parameter descriptions are already present. The description adds 'signed' and 'photo URLs' context but does not elaborate on parameter constraints or recommended usage 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 states the tool gets signed photo URLs for a place, which is a clear verb+resource combination. It distinguishes from general search tools but lacks differentiation from places_details which also provides photos.
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 like places_details or nearby_find. The description does not specify prerequisites or use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
places_search_textB
Search for places using natural language queries with advanced filtering options. Supports place type filtering, rating thresholds, price levels, location biasing, and real-time availability status.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Text search query for places. Examples: "pizza near me", "Italian restaurants in Rome", "gas stations", "Starbucks in Seattle" | |
| region | No | Region code for biasing results (ISO 3166-1 alpha-2, e.g., "US", "GB", "DE") | |
| language | No | Language code for results (ISO 639-1, e.g., "en", "es", "fr") | |
| open_now | No | Filter for places open now | |
| min_rating | No | Minimum rating filter (1.0-5.0). Example: 4.0 for highly rated places only | |
| max_results | No | ||
| price_levels | No | Price levels to filter by (0=Free, 1=Inexpensive, 2=Moderate, 3=Expensive, 4=Very Expensive). Example: [1, 2] for inexpensive to moderate | |
| location_bias | No | ||
| excluded_types | No | Place types to exclude | |
| included_types | No | Place types to include | |
| rank_preference | No | How to rank the results |
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 does not disclose what the tool returns, any pagination, limits, or side effects. Mentions filters but lacks operational details like rate limits or prerequisites.
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 two sentences long, front-loaded with the core action, and contains no redundant information. Every phrase contributes to understanding the tool's purpose and capabilities.
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 complexity (11 parameters, nested objects, no output schema), the description is insufficient. It does not explain return format, pagination, or any operational constraints, leaving significant gaps 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?
Schema coverage is 82%, so the schema already documents most parameters. The description adds value by summarizing filter categories (rating, price, location) but does not provide new per-parameter meaning beyond what the schema offers.
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 places using natural language queries with filtering options, which distinguishes it from sibling tools like 'places_nearby' which are location-based. The verb 'search' and resource 'places' are specific.
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 use for text-based queries but does not explicitly contrast with sibling tools like 'places_nearby' or 'places_autocomplete'. No guidance on when not to use or alternatives is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
roads_nearestC
Find nearest roads to given points
| Name | Required | Description | Default |
|---|---|---|---|
| points | Yes | Array of geographic coordinates to find nearest roads for. Each point should be an object like {"lat": 40.7128, "lng": -74.0060} | |
| travel_mode | No | Travel mode for road network |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It merely restates the name, omitting any details about output format, result count, distance units, or potential limitations like rate limits or data freshness.
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 brief (5 words), which is not necessarily conciseβit under-specifies. While it avoids fluff, it sacrifices necessary information, making it only marginally acceptable.
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 tool with 2 parameters and no output schema, the description is severely incomplete. It fails to define what 'nearest' means in terms of count or distance, what the output structure looks like, or how travel_mode affects results.
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?
The input schema has 100% coverage, with both parameters (points and travel_mode) already well-described. The description adds no additional semantic meaning beyond the schema, so a baseline score of 3 is appropriate.
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 'Find nearest roads to given points' uses a specific verb ('find') and resource ('nearest roads'), clearly distinguishing this tool from siblings like nearby_find (which finds places) and routes_compute (which computes directions).
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 guidance on when to use this tool versus alternatives such as routes_compute or nearby_find. It does not mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
routes_computeB
Calculate optimal routes between locations with real-time traffic data, toll information, and alternative route options. Supports multiple travel modes including driving, walking, cycling, and transit.
| Name | Required | Description | Default |
|---|---|---|---|
| units | No | Unit system for distances | |
| origin | Yes | Starting location for the route. Provide either coordinates like {"lat": 37.7749, "lng": -122.4194} or an address like {"address": "123 Main St, San Francisco, CA"} | |
| region | No | Region code for biasing results (ISO 3166-1 alpha-2, e.g., "US", "GB", "DE") | |
| language | No | Language code for results (ISO 639-1, e.g., "en", "es", "fr") | |
| waypoints | No | Optional intermediate stops along the route. Each waypoint should have a "location" (coordinates or address) and optionally "via": true for pass-through points. Example: [{"location": {"lat": 38.0, "lng": -122.0}, "via": false}] | |
| avoid_tolls | No | Avoid toll roads | |
| destination | Yes | Ending location for the route. Provide either coordinates like {"lat": 40.7128, "lng": -74.0060} or an address like {"address": "456 Broadway, New York, NY"} | |
| travel_mode | No | Transportation mode for the route | |
| avoid_ferries | No | Avoid ferries | |
| avoid_highways | No | Avoid highways | |
| routing_preference | No | Routing algorithm preference | |
| compute_alternative_routes | No | Whether to compute alternative routes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full weight. It mentions key features but fails to disclose what the output contains (e.g., distances, durations, directions), required permissions, rate limits, or other behavioral traits. The description is insufficient for a complex tool with many parameters.
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 at two sentences, front-loading the core purpose and key differentiators. Every word adds value with no redundancy or filler.
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 tool with 12 parameters and no output schema, the description lacks crucial details about return values (e.g., route geometry, steps, duration), prerequisites, and common use-cases. It is incomplete for effective agent decision-making.
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 description coverage is 100%, so each parameter already has a description. The tool description adds high-level context (traffic, tolls, modes) but does not enhance understanding of individual parameters beyond what the schema provides. Baseline 3 applies.
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's purpose ('Calculate optimal routes between locations') with specific features (real-time traffic, toll information, alternatives) and supported modes (driving, walking, cycling, transit). It distinguishes this from siblings like routes_matrix, which is a different operation.
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?
While the description outlines capabilities, it does not provide explicit guidance on when to use this versus alternatives like routes_matrix or other routing tools. It lacks when-not or exclusion criteria, leaving the agent to infer based on feature listings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
routes_matrixB
Compute distance matrix between multiple origins and destinations
| Name | Required | Description | Default |
|---|---|---|---|
| units | No | Unit system for distances | |
| region | No | Region code for biasing results (ISO 3166-1 alpha-2, e.g., "US", "GB", "DE") | |
| origins | Yes | Array of starting locations for distance calculations. Each location should be either coordinates like {"lat": 37.7749, "lng": -122.4194} or an address like {"address": "San Francisco, CA"} | |
| language | No | Language code for results (ISO 639-1, e.g., "en", "es", "fr") | |
| travel_mode | No | Transportation mode for distance calculations | |
| destinations | Yes | Array of destination locations for distance calculations. Each location should be either coordinates like {"lat": 40.7128, "lng": -74.0060} or an address like {"address": "New York, NY"} | |
| routing_preference | No | Routing algorithm preference |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits such as rate limits, data limitations (e.g., maximum matrix size), or side effects. The description is purely functional.
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 a single, concise sentence with no wasted words. It is appropriately sized for a simple tool with well-documented parameters.
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?
Despite high schema coverage, the description lacks context for the output format (no output schema) and does not differentiate from similar tools. The agent may not know what the tool returns or how it behaves.
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 description coverage is 100%, so the input schema already describes all parameters well. The tool description adds no additional meaning beyond what the schema provides. Baseline is 3.
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 'Compute distance matrix between multiple origins and destinations', which is a specific verb+resource. This distinguishes it from sibling tools like 'routes_compute' (likely single route) and 'nearby_find'.
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 usage guidelines provided. The description does not indicate when to use this tool versus alternatives, nor does it mention prerequisites or context. The agent must infer from the name and sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
timezone_getC
Get timezone information for a location
| Name | Required | Description | Default |
|---|---|---|---|
| lat | Yes | Latitude of the location | |
| lng | Yes | Longitude of the location | |
| language | No | Language code for results (ISO 639-1, e.g., "en", "es", "fr") | |
| timestamp | No | Unix timestamp (optional) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description does not disclose behavioral traits such as rate limits, authentication, error handling, or behavior for invalid coordinates. Does not mention impact of optional 'timestamp' on DST.
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?
Extremely brief single sentence, but fails to provide necessary details. Not front-loaded with actionable info; does not earn its place given the complexity of the tool.
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 and no annotations; description is insufficient for an agent to understand return format or behavior. For a tool with 4 parameters (2 optional), more context is essential.
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 fully describes all 4 parameters with descriptions. Description adds no extra meaning beyond the schema; for example, it does not explain how 'language' affects output or that 'timestamp' adjusts for DST.
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 the tool retrieves timezone information for a location, distinguishing it from sibling tools like elevation_get or geocode. However, it lacks specificity about what information is returned (e.g., offset, DST).
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 vs alternatives like geocode_reverse or places_details. No mention of prerequisites, required input constraints, or context for the optional parameters.
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.
15 tool updates
v0.0.0-dev- First observed
elevation_get - First observed
geocode_reverse - First observed
geocode_search - First observed
geolocation_estimate - First observed
ip_geolocate - First observed
nearby_find - First observed
places_autocomplete - First observed
places_details - First observed
places_nearby - First observed
places_photos - First observed
places_search_text - First observed
roads_nearest - First observed
routes_compute - First observed
routes_matrix - First observed
timezone_get
TDQS
Scored across 15 tools
Most tools have distinct purposes, but 'nearby_find' and 'places_nearby' both discover nearby places, causing potential confusion. Descriptions help differentiate, but there is some overlap.
Names follow a consistent verb_noun pattern with underscores, though some are action-first (e.g., elevation_get) and others domain-first (e.g., geocode_reverse). Overall pattern is predictable.
15 tools cover a wide range of Google Maps API functionalities including geocoding, places, routes, elevation, and timezone. The count is well-scoped for the domain.
The tool set covers major Google Maps API categories comprehensively, including directions, distance matrix, places, geocoding, and more. No obvious gaps for typical use cases.
Maintenance
Related MCP Connectors
Google Maps MCP Pack β geocoding, places, directions, distance matrix, elevation.
Geoapify MCP β wraps the Geoapify Location Platform (geoapify.com)
Live Google Maps business search, review, and photo data for AI agents over MCP.
Search Google Maps businesses via MCP - name, address, phone, rating, hours, GPS.
Related MCP Servers
- AlicenseCqualityDmaintenanceProvides access to Google Maps API functionality including geocoding, place search, direction routing, and distance calculations through a structured MCP interface.48MIT
- AlicenseAqualityDmaintenanceProvides access to Google Maps API functionality including places search, geocoding, directions, distance matrix, elevation data, and static map generation through the MCP interface.8101MIT
- AlicenseNot gradedqualityBmaintenanceProvides MCP tools for Google Maps services including directions, geocoding, distance matrix, and places search.14Apache 2.0
- FlicenseNot gradedqualityDmaintenanceComprehensive MCP server for Google Maps APIs, enabling geocoding, place search and details, distance matrix, elevation, and directions through natural language.6-