GrabMaps MCP Server

A Model Context Protocol (MCP) server for GrabMaps API integration, providing access to GrabMaps services through AWS Location Service.

Do note that this MCP server is NOT officially affiliated with Grab, GrabMaps, or AWS Location Service.

Important: GrabMaps only supports eight countries in Southeast Asia.
🇲🇾 Malaysia (MYS)
🇸🇬 Singapore (SGP)
🇹🇭 Thailand (THA)
🇲🇲 Myanmar (MMR)
🇰🇭 Cambodia (KHM)
🇻🇳 Vietnam (VNM)
🇵🇭 Philippines (PHL)
🇮🇩 Indonesia (IDN)
Search requests outside these countries will not return accurate results.

Features

This MCP server provides access to GrabMaps functionality through two main categories:

Places Actions (Available via MCP)

SearchPlaceIndexForText: Forward geocoding to find places by name or address
SearchPlaceIndexForPosition: Reverse geocoding to find places by coordinates
SearchPlaceIndexForSuggestions: Get place suggestions as you type
GetPlace: Retrieve detailed information about a specific place

Routes Actions (Available via MCP)

CalculateRoute: Calculate routes between points with waypoints
CalculateRouteMatrix: Calculate a matrix of routes between multiple origins and destinations

Maps Functionality (Requires AWS Console)

Note: Map rendering functionality is not directly available through the MCP server. To view and use maps:

Go to the AWS Location Service console
Look for the Maps section and click the "Try it" button
Ensure "Grab" is selected as the provider

To explore GrabMaps data coverage and see the maps in action without logging in to AWS, visit: https://grabmaps.grab.com/explore-data-coverage

Installation

From NPM

npm install mcp-grabmaps

From Source

git clone https://github.com/hithereiamaliff/mcp-grabmaps.git
cd mcp-grabmaps
npm install

Configuration

Create a .env file in the root directory with the following variables:

# GrabMaps API credentials
GRABMAPS_API_KEY=your_grabmaps_api_key_here

# AWS credentials for AWS Location Service
AWS_ACCESS_KEY_ID=your_aws_access_key_id_here
AWS_SECRET_ACCESS_KEY=your_aws_secret_access_key_here
AWS_REGION=ap-southeast-5  # Default region for Malaysia (ap-southeast-1 for Singapore)

# Place Index name (default for GrabMaps)
PLACE_INDEX_NAME=explore.place.Grab

# Map name (for rendering maps)
MAP_NAME=explore.map.Grab

# Route calculator name
ROUTE_CALCULATOR_NAME=explore.route-calculator.Grab

# Server port
PORT=3000

Usage

Running Locally

# Development mode
npm run dev

# Production mode
npm run build
npm start

Using with Smithery

# Run in development mode
npm run smithery:dev

# Build for production
npm run smithery:build

# Deploy to Smithery
npm run smithery:deploy

Testing in Smithery Playground

For the best experience testing Places and Routes APIs, we recommend using the Smithery playground:

Start your MCP server locally: npm run dev
Open the Smithery playground at: https://smithery.ai/playground
Connect to your local MCP server: http://localhost:3000
Test Places and Routes API calls using the provided examples in SMITHERY_TESTING.md

Important Notes for AI Models

Supported Countries

GrabMaps ONLY supports the following eight countries in Southeast Asia:

Malaysia (MYS)
Singapore (SGP)
Thailand (THA)
Myanmar (MMR)
Cambodia (KHM)
Vietnam (VNM)
Philippines (PHL)
Indonesia (IDN)

AI models should not attempt to use GrabMaps for locations outside these countries as results will be inaccurate or non-existent.

Country Code Requirements

When using the Places API functions, AI models MUST analyze the user's query to determine the appropriate country and include the three-letter ISO country code in all requests:

{
  "query": "City Square Mall",
  "country": "SGP"  // SGP for Singapore, MYS for Malaysia, THA for Thailand, etc.
}

Examples of country codes:

Singapore: SGP
Malaysia: MYS
Thailand: THA
Indonesia: IDN
Philippines: PHL
Vietnam: VNM

Including the country code is critical for returning accurate search results.

This approach allows you to test the Places and Routes functionality without needing to set up map visualization components.

Example API Calls

Forward Geocoding

const response = await fetch('http://localhost:3000/searchPlaceIndexForText', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    query: 'KLCC, Kuala Lumpur',
    country: 'my',
    maxResults: 5
  })
});

const data = await response.json();
console.log(data);

Calculate Route

const response = await fetch('http://localhost:3000/calculateRoute', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    origin: {
      longitude: 101.6942371,
      latitude: 3.1516964
    },
    destination: {
      longitude: 101.7113,
      latitude: 3.1421
    },
    travelMode: 'Car'
  })
});

const data = await response.json();
console.log(data);

Integrating with AI Models

This MCP server can be integrated with AI models that support the Model Context Protocol. Example integration with an AI model:

// Example of how an AI model would use this MCP server
const result = await mcpClient.call('grabmaps', 'searchPlaceIndexForText', {
  query: 'KLCC, Kuala Lumpur',
  country: 'my'
});

// The AI model can then use the result in its response
console.log(`The coordinates of KLCC are: ${result.results[0].coordinates.latitude}, ${result.results[0].coordinates.longitude}`);

AWS Location Service Setup

Before using this MCP server, you need to set up the following resources in AWS Location Service:

Create a Place Index with GrabMaps as the data provider
Create a Map with GrabMaps as the data provider
Create a Route Calculator with GrabMaps as the data provider

Map Component Limitations and Recommended Approach

The Maps API components have certain limitations when used through the MCP server:

Map tiles returned by the getMapTile endpoint are binary data encoded as base64 strings
Font stacks for getMapGlyphs must match those supported by GrabMaps via AWS Location Service
Sprite filenames for getMapSprites must follow specific regex patterns
Maximum zoom levels are restricted (typically max zoom 14)

Recommended Approach:

For Maps: Use direct integration with GrabMaps via MapLibre GL and AWS Location Service as shown in the official demo
For Places and Routes: Use the MCP server through the Smithery playground or direct API calls

This separation allows for optimal performance and visualization while still leveraging the MCP server for Places and Routes functionality.

Official GrabMaps MapLibre GL Demo

A comprehensive demo using the official GrabMaps integration with MapLibre GL is included in the examples/official-map-demo directory. This demo provides a complete testing interface for all GrabMaps components:

Places API: Forward/reverse geocoding and place details
Maps API: Map tiles, style descriptors, sprites, and glyphs
Routes API: Route calculation and route matrix

The demo features a tabbed interface for easy testing of different components and provides detailed feedback for each API call.

Key Features

Interactive map using official GrabMaps map tiles via MapLibre GL
Tabbed interface for testing different GrabMaps components
Comprehensive testing of all API endpoints
Configurable API key, region, and resource names
Visual display of routes, search results, and map components

To run the demo:

# Start the MCP server
npm start

# Then open examples/official-map-demo/index.html in your browser

See the Official Map Demo README for setup and usage instructions.

Testing

A comprehensive test suite is included in the tests directory to verify all endpoints are working correctly. For detailed testing instructions, examples, and troubleshooting tips, please refer to the TESTING.md file.

To run the tests:

# Start the MCP server in one terminal
npm start

# Run the test suite in another terminal
node tests/test-suite.js

License

This project is licensed under the MIT License - see the LICENSE file for details.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

This server cannot be installed

security - not tested

license - permissive license

quality - not tested

How are these scores calculated?

hybrid server

The server is able to function both locally and remotely, depending on the configuration or use case.

Provides access to GrabMaps services (Places, Maps, Routes) through AWS Location Service using the Model Context Protocol.

Related MCP Servers

MCP Google Map Server
cablate
A
security
A
license
A
quality
A Model Context Protocol server that provides Google Maps API integration, allowing users to search locations, get place details, geocode addresses, calculate distances, obtain directions, and retrieve elevation data through LLM processing capabilities.
Last updated -
7
817
60
TypeScript
MIT License
Google Maps MCP Server
Moe03
A
security
A
license
A
quality
Provides access to Google Maps API functionality including geocoding, place search, direction routing, and distance calculations through a structured MCP interface.
Last updated -
4
5
JavaScript
MIT License
AMap MCP Server
Francis235
A
security
A
license
A
quality
Non-official Model Context Protocol server that enables interaction with AMap's location services through clients like Cursor, Claude Desktop, Cline, and Windsurf.
Last updated -
1
1
Python
MIT License
네이버 길찾기 MCP 서버
Chaeyun06
A
security
F
license
A
quality
Enables users to access Naver Maps API functionality including directions, place search, geocoding, and reverse geocoding through a Model Context Protocol server.
Last updated -
4
JavaScript

View all related MCP servers

GrabMaps MCP Server