MCP Google Map Server

Instructions

Implementation Reference

• src/tools/maps/searchNearby.ts:21-51 (handler)

  Main handler function that executes the tool logic: creates PlacesSearcher instance and calls its searchNearby method, formats the response.

  async function ACTION(params: SearchNearbyParams): Promise<{ content: any[]; isError?: boolean }> {
    try {
      // Create a new PlacesSearcher instance with the current request's API key
      const apiKey = getCurrentApiKey();
      const placesSearcher = new PlacesSearcher(apiKey);
      const result = await placesSearcher.searchNearby(params);
  
      if (!result.success) {
        return {
          content: [{ type: "text", text: result.error || "Search failed" }],
          isError: true,
        };
      }
  
      return {
        content: [
          {
            type: "text",
            text: `location: ${JSON.stringify(result.location, null, 2)}\n` + JSON.stringify(result.data, null, 2),
          },
        ],
        isError: false,
      };
    } catch (error: any) {
      const errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
      return {
        isError: true,
        content: [{ type: "text", text: `Error searching nearby places: ${errorMessage}` }],
      };
    }
  }

• src/tools/maps/searchNearby.ts:8-17 (schema)

  Zod schema defining input parameters for the search_nearby tool.

  const SCHEMA = {
    center: z.object({
      value: z.string().describe("Address, landmark name, or coordinates (coordinate format: lat,lng)"),
      isCoordinates: z.boolean().default(false).describe("Whether the value is coordinates"),
    }).describe("Search center point (e.g. value: 49.3268778,-123.0585982, isCoordinates: true)"),
    keyword: z.string().optional().describe("Search keyword (e.g., restaurant, cafe, hotel)"),
    radius: z.number().default(1000).describe("Search radius in meters"),
    openNow: z.boolean().default(false).describe("Only show places that are currently open"),
    minRating: z.number().min(0).max(5).optional().describe("Minimum rating requirement (0-5)"),
  };

• src/config.ts:24-28 (registration)

  Registration of the search_nearby tool in the server configuration array.

    name: SearchNearby.NAME,
    description: SearchNearby.DESCRIPTION,
    schema: SearchNearby.SCHEMA,
    action: (params: SearchNearbyParams) => SearchNearby.ACTION(params),
  },

• src/services/PlacesSearcher.ts:77-107 (helper)

  Helper method in PlacesSearcher class that performs the actual nearby search using Google Maps tools and processes results.

  async searchNearby(params: { center: { value: string; isCoordinates: boolean }; keyword?: string; radius?: number; openNow?: boolean; minRating?: number }): Promise<SearchNearbyResponse> {
    try {
      const location = await this.mapsTools.getLocation(params.center);
      const places = await this.mapsTools.searchNearbyPlaces({
        location,
        keyword: params.keyword,
        radius: params.radius,
        openNow: params.openNow,
        minRating: params.minRating,
      });
  
      return {
        location: location,
        success: true,
        data: places.map((place) => ({
          name: place.name,
          place_id: place.place_id,
          address: place.formatted_address,
          location: place.geometry.location,
          rating: place.rating,
          total_ratings: place.user_ratings_total,
          open_now: place.opening_hours?.open_now,
        })),
      };
    } catch (error) {
      return {
        success: false,
        error: error instanceof Error ? error.message : "An error occurred during search",
      };
    }
  }

• src/services/toolclass.ts:70-96 (helper)

  Low-level helper in GoogleMapsTools that calls Google Places API placesNearby and applies minRating filter.

  async searchNearbyPlaces(params: SearchParams): Promise<PlaceResult[]> {
    const searchParams = {
      location: params.location,
      radius: params.radius || 1000,
      keyword: params.keyword,
      opennow: params.openNow,
      language: this.defaultLanguage,
      key: this.apiKey,
    };
  
    try {
      const response = await this.client.placesNearby({
        params: searchParams,
      });
  
      let results = response.data.results;
  
      if (params.minRating) {
        results = results.filter((place) => (place.rating || 0) >= (params.minRating || 0));
      }
  
      return results as PlaceResult[];
    } catch (error: any) {
      Logger.error("Error in searchNearbyPlaces:", error);
      throw new Error(`Failed to search nearby places: ${extractErrorMessage(error)}`);
    }
  }