feat: add new tools

README.md

@@ -6,9 +6,24 @@ A powerful Model Context Protocol (MCP) server providing comprehensive Google Ma
 
 ### Google Maps Features
 
-- Location search and information retrieval
-- Geocoding and reverse geocoding
-- Detailed place information
+- **Location Search**
+
+  - Search for places near a specific location with customizable radius and filters
+  - Get detailed place information including ratings, opening hours, and contact details
+
+- **Geocoding Services**
+
+  - Convert addresses to coordinates (geocoding)
+  - Convert coordinates to addresses (reverse geocoding)
+
+- **Distance & Directions**
+
+  - Calculate distances and travel times between multiple origins and destinations
+  - Get detailed directions between two points with step-by-step instructions
+  - Support for different travel modes (driving, walking, bicycling, transit)
+
+- **Elevation Data**
+  - Retrieve elevation data for specific locations
 
 ## Installation
 
@@ -48,6 +63,18 @@ mcp-google-map
 
 3. Click "Save" to complete the installation
 
+## Available Tools
+
+The server provides the following tools:
+
+1. **search_nearby** - Search for places near a specific location
+2. **get_place_details** - Get detailed information about a specific place
+3. **maps_geocode** - Convert an address to coordinates
+4. **maps_reverse_geocode** - Convert coordinates to an address
+5. **maps_distance_matrix** - Calculate distances and times between multiple origins and destinations
+6. **maps_directions** - Get directions between two points
+7. **maps_elevation** - Get elevation data for specific locations
+
 ## Google Maps API Setup
 
 To use this service, you need to:

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cablate/mcp-google-map",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "scripts": {
     "build": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.cjs --external:pdfreader --external:jsdom --external:mammoth --external:csv-parse --external:libreoffice-convert && shx chmod +x dist/index.cjs",

src/index.ts

@@ -3,10 +3,10 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { GET_PLACE_DETAILS_TOOL, SEARCH_NEARBY_TOOL } from "./maps-tools/mapsTools.js";
+import { DIRECTIONS_TOOL, DISTANCE_MATRIX_TOOL, ELEVATION_TOOL, GEOCODE_TOOL, GET_PLACE_DETAILS_TOOL, REVERSE_GEOCODE_TOOL, SEARCH_NEARBY_TOOL } from "./maps-tools/mapsTools.js";
 import { PlacesSearcher } from "./maps-tools/searchPlaces.js";
 
-const tools = [SEARCH_NEARBY_TOOL, GET_PLACE_DETAILS_TOOL];
+const tools = [SEARCH_NEARBY_TOOL, GET_PLACE_DETAILS_TOOL, GEOCODE_TOOL, REVERSE_GEOCODE_TOOL, DISTANCE_MATRIX_TOOL, DIRECTIONS_TOOL, ELEVATION_TOOL];
 const placesSearcher = new PlacesSearcher();
 
 const server = new Server(
@@ -94,6 +94,136 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       };
     }
 
+    if (name === "maps_geocode") {
+      const { address } = args as {
+        address: string;
+      };
+
+      const result = await placesSearcher.geocode(address);
+
+      if (!result.success) {
+        return {
+          content: [{ type: "text", text: result.error || "地址轉換座標失敗" }],
+          isError: true,
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result.data, null, 2),
+          },
+        ],
+        isError: false,
+      };
+    }
+
+    if (name === "maps_reverse_geocode") {
+      const { latitude, longitude } = args as {
+        latitude: number;
+        longitude: number;
+      };
+
+      const result = await placesSearcher.reverseGeocode(latitude, longitude);
+
+      if (!result.success) {
+        return {
+          content: [{ type: "text", text: result.error || "座標轉換地址失敗" }],
+          isError: true,
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result.data, null, 2),
+          },
+        ],
+        isError: false,
+      };
+    }
+
+    if (name === "maps_distance_matrix") {
+      const { origins, destinations, mode } = args as {
+        origins: string[];
+        destinations: string[];
+        mode?: "driving" | "walking" | "bicycling" | "transit";
+      };
+
+      const result = await placesSearcher.calculateDistanceMatrix(origins, destinations, mode || "driving");
+
+      if (!result.success) {
+        return {
+          content: [{ type: "text", text: result.error || "計算距離矩陣失敗" }],
+          isError: true,
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result.data, null, 2),
+          },
+        ],
+        isError: false,
+      };
+    }
+
+    if (name === "maps_directions") {
+      const { origin, destination, mode } = args as {
+        origin: string;
+        destination: string;
+        mode?: "driving" | "walking" | "bicycling" | "transit";
+      };
+
+      const result = await placesSearcher.getDirections(origin, destination, mode || "driving");
+
+      if (!result.success) {
+        return {
+          content: [{ type: "text", text: result.error || "獲取路線指引失敗" }],
+          isError: true,
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result.data, null, 2),
+          },
+        ],
+        isError: false,
+      };
+    }
+
+    if (name === "maps_elevation") {
+      const { locations } = args as {
+        locations: Array<{ latitude: number; longitude: number }>;
+      };
+
+      const result = await placesSearcher.getElevation(locations);
+
+      if (!result.success) {
+        return {
+          content: [{ type: "text", text: result.error || "獲取海拔數據失敗" }],
+          isError: true,
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result.data, null, 2),
+          },
+        ],
+        isError: false,
+      };
+    }
+
     return {
       content: [{ type: "text", text: `錯誤：未知的工具 ${name}` }],
       isError: true,

src/maps-tools/mapsTools.ts

@@ -8,7 +8,7 @@ export const SEARCH_NEARBY_TOOL = {
         type: "object",
         properties: {
           value: { type: "string", description: "地址、地標名稱或經緯度座標(經緯度座標格式: lat,lng)" },
-          isCoordinates: { type: "boolean", description: "是否為經緯度座標", default: false }
+          isCoordinates: { type: "boolean", description: "是否為經緯度座標", default: false },
         },
         required: ["value"],
         description: "搜尋中心點",
@@ -38,6 +38,125 @@ export const SEARCH_NEARBY_TOOL = {
   },
 };
 
+export const GEOCODE_TOOL = {
+  name: "maps_geocode",
+  description: "將地址轉換為座標",
+  inputSchema: {
+    type: "object",
+    properties: {
+      address: {
+        type: "string",
+        description: "要轉換的地址或地標名稱",
+      },
+    },
+    required: ["address"],
+  },
+};
+
+export const REVERSE_GEOCODE_TOOL = {
+  name: "maps_reverse_geocode",
+  description: "將座標轉換為地址",
+  inputSchema: {
+    type: "object",
+    properties: {
+      latitude: {
+        type: "number",
+        description: "緯度",
+      },
+      longitude: {
+        type: "number",
+        description: "經度",
+      },
+    },
+    required: ["latitude", "longitude"],
+  },
+};
+
+export const DISTANCE_MATRIX_TOOL = {
+  name: "maps_distance_matrix",
+  description: "計算多個起點和終點之間的距離和時間",
+  inputSchema: {
+    type: "object",
+    properties: {
+      origins: {
+        type: "array",
+        items: {
+          type: "string",
+        },
+        description: "起點地址或座標列表",
+      },
+      destinations: {
+        type: "array",
+        items: {
+          type: "string",
+        },
+        description: "終點地址或座標列表",
+      },
+      mode: {
+        type: "string",
+        enum: ["driving", "walking", "bicycling", "transit"],
+        description: "交通模式",
+        default: "driving",
+      },
+    },
+    required: ["origins", "destinations"],
+  },
+};
+
+export const DIRECTIONS_TOOL = {
+  name: "maps_directions",
+  description: "獲取兩點之間的路線指引",
+  inputSchema: {
+    type: "object",
+    properties: {
+      origin: {
+        type: "string",
+        description: "起點地址或座標",
+      },
+      destination: {
+        type: "string",
+        description: "終點地址或座標",
+      },
+      mode: {
+        type: "string",
+        enum: ["driving", "walking", "bicycling", "transit"],
+        description: "交通模式",
+        default: "driving",
+      },
+    },
+    required: ["origin", "destination"],
+  },
+};
+
+export const ELEVATION_TOOL = {
+  name: "maps_elevation",
+  description: "獲取位置的海拔數據",
+  inputSchema: {
+    type: "object",
+    properties: {
+      locations: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            latitude: {
+              type: "number",
+              description: "緯度",
+            },
+            longitude: {
+              type: "number",
+              description: "經度",
+            },
+          },
+          required: ["latitude", "longitude"],
+        },
+        description: "要獲取海拔數據的位置列表",
+      },
+    },
+    required: ["locations"],
+  },
+};
+
 export const GET_PLACE_DETAILS_TOOL = {
   name: "get_place_details",
   description: "獲取特定地點的詳細資訊",

src/maps-tools/searchPlaces.ts

@@ -13,6 +13,57 @@ interface PlaceDetailsResponse {
   data?: any;
 }
 
+interface GeocodeResponse {
+  success: boolean;
+  error?: string;
+  data?: {
+    location: { lat: number; lng: number };
+    formatted_address: string;
+    place_id: string;
+  };
+}
+
+interface ReverseGeocodeResponse {
+  success: boolean;
+  error?: string;
+  data?: {
+    formatted_address: string;
+    place_id: string;
+    address_components: any[];
+  };
+}
+
+interface DistanceMatrixResponse {
+  success: boolean;
+  error?: string;
+  data?: {
+    distances: any[][];
+    durations: any[][];
+    origin_addresses: string[];
+    destination_addresses: string[];
+  };
+}
+
+interface DirectionsResponse {
+  success: boolean;
+  error?: string;
+  data?: {
+    routes: any[];
+    summary: string;
+    total_distance: { value: number; text: string };
+    total_duration: { value: number; text: string };
+  };
+}
+
+interface ElevationResponse {
+  success: boolean;
+  error?: string;
+  data?: Array<{
+    elevation: number;
+    location: { lat: number; lng: number };
+  }>;
+}
+
 export class PlacesSearcher {
   private mapsTools: GoogleMapsTools;
 
@@ -84,4 +135,84 @@ export class PlacesSearcher {
       };
     }
   }
+
+  async geocode(address: string): Promise<GeocodeResponse> {
+    try {
+      const result = await this.mapsTools.geocode(address);
+
+      return {
+        success: true,
+        data: result,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "地址轉換座標時發生錯誤",
+      };
+    }
+  }
+
+  async reverseGeocode(latitude: number, longitude: number): Promise<ReverseGeocodeResponse> {
+    try {
+      const result = await this.mapsTools.reverseGeocode(latitude, longitude);
+
+      return {
+        success: true,
+        data: result,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "座標轉換地址時發生錯誤",
+      };
+    }
+  }
+
+  async calculateDistanceMatrix(origins: string[], destinations: string[], mode: "driving" | "walking" | "bicycling" | "transit" = "driving"): Promise<DistanceMatrixResponse> {
+    try {
+      const result = await this.mapsTools.calculateDistanceMatrix(origins, destinations, mode);
+
+      return {
+        success: true,
+        data: result,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "計算距離矩陣時發生錯誤",
+      };
+    }
+  }
+
+  async getDirections(origin: string, destination: string, mode: "driving" | "walking" | "bicycling" | "transit" = "driving"): Promise<DirectionsResponse> {
+    try {
+      const result = await this.mapsTools.getDirections(origin, destination, mode);
+
+      return {
+        success: true,
+        data: result,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "獲取路線指引時發生錯誤",
+      };
+    }
+  }
+
+  async getElevation(locations: Array<{ latitude: number; longitude: number }>): Promise<ElevationResponse> {
+    try {
+      const result = await this.mapsTools.getElevation(locations);
+
+      return {
+        success: true,
+        data: result,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "獲取海拔數據時發生錯誤",
+      };
+    }
+  }
 }

src/maps-tools/toolclass.ts

@@ -1,4 +1,4 @@
-import { Client, Language } from "@googlemaps/google-maps-services-js";
+import { Client, Language, TravelMode } from "@googlemaps/google-maps-services-js";
 import dotenv from "dotenv";
 
 // 確保環境變數被載入
@@ -32,6 +32,8 @@ interface PlaceResult {
 interface GeocodeResult {
   lat: number;
   lng: number;
+  formatted_address?: string;
+  place_id?: string;
 }
 
 export class GoogleMapsTools {
@@ -97,18 +99,21 @@ export class GoogleMapsTools {
         params: {
           address: address,
           key: process.env.GOOGLE_MAPS_API_KEY || "",
-          language: this.defaultLanguage
-        }
+          language: this.defaultLanguage,
+        },
       });
 
       if (response.data.results.length === 0) {
         throw new Error("找不到該地址的位置");
       }
 
-      const location = response.data.results[0].geometry.location;
+      const result = response.data.results[0];
+      const location = result.geometry.location;
       return {
         lat: location.lat,
-        lng: location.lng
+        lng: location.lng,
+        formatted_address: result.formatted_address,
+        place_id: result.place_id,
       };
     } catch (error) {
       console.error("Error in geocodeAddress:", error);
@@ -117,7 +122,7 @@ export class GoogleMapsTools {
   }
 
   private parseCoordinates(coordString: string): GeocodeResult {
-    const coords = coordString.split(',').map(c => parseFloat(c.trim()));
+    const coords = coordString.split(",").map((c) => parseFloat(c.trim()));
     if (coords.length !== 2 || isNaN(coords[0]) || isNaN(coords[1])) {
       throw new Error("無效的座標格式，請使用「緯度,經度」格式");
     }
@@ -130,4 +135,204 @@ export class GoogleMapsTools {
     }
     return this.geocodeAddress(center.value);
   }
+
+  // 新增公開方法用於地址轉座標
+  async geocode(address: string): Promise<{
+    location: { lat: number; lng: number };
+    formatted_address: string;
+    place_id: string;
+  }> {
+    try {
+      const result = await this.geocodeAddress(address);
+      return {
+        location: { lat: result.lat, lng: result.lng },
+        formatted_address: result.formatted_address || "",
+        place_id: result.place_id || "",
+      };
+    } catch (error) {
+      console.error("Error in geocode:", error);
+      throw new Error("地址轉換座標時發生錯誤");
+    }
+  }
+
+  async reverseGeocode(
+    latitude: number,
+    longitude: number
+  ): Promise<{
+    formatted_address: string;
+    place_id: string;
+    address_components: any[];
+  }> {
+    try {
+      const response = await this.client.reverseGeocode({
+        params: {
+          latlng: { lat: latitude, lng: longitude },
+          language: this.defaultLanguage,
+          key: process.env.GOOGLE_MAPS_API_KEY || "",
+        },
+      });
+
+      if (response.data.results.length === 0) {
+        throw new Error("找不到該座標的地址");
+      }
+
+      const result = response.data.results[0];
+      return {
+        formatted_address: result.formatted_address,
+        place_id: result.place_id,
+        address_components: result.address_components,
+      };
+    } catch (error) {
+      console.error("Error in reverseGeocode:", error);
+      throw new Error("座標轉換地址時發生錯誤");
+    }
+  }
+
+  async calculateDistanceMatrix(
+    origins: string[],
+    destinations: string[],
+    mode: "driving" | "walking" | "bicycling" | "transit" = "driving"
+  ): Promise<{
+    distances: any[][];
+    durations: any[][];
+    origin_addresses: string[];
+    destination_addresses: string[];
+  }> {
+    try {
+      const response = await this.client.distancematrix({
+        params: {
+          origins: origins,
+          destinations: destinations,
+          mode: mode as TravelMode,
+          language: this.defaultLanguage,
+          key: process.env.GOOGLE_MAPS_API_KEY || "",
+        },
+      });
+
+      const result = response.data;
+
+      if (result.status !== "OK") {
+        throw new Error(`距離矩陣計算失敗: ${result.status}`);
+      }
+
+      const distances: any[][] = [];
+      const durations: any[][] = [];
+
+      result.rows.forEach((row: any) => {
+        const distanceRow: any[] = [];
+        const durationRow: any[] = [];
+
+        row.elements.forEach((element: any) => {
+          if (element.status === "OK") {
+            distanceRow.push({
+              value: element.distance.value,
+              text: element.distance.text,
+            });
+            durationRow.push({
+              value: element.duration.value,
+              text: element.duration.text,
+            });
+          } else {
+            distanceRow.push(null);
+            durationRow.push(null);
+          }
+        });
+
+        distances.push(distanceRow);
+        durations.push(durationRow);
+      });
+
+      return {
+        distances: distances,
+        durations: durations,
+        origin_addresses: result.origin_addresses,
+        destination_addresses: result.destination_addresses,
+      };
+    } catch (error) {
+      console.error("Error in calculateDistanceMatrix:", error);
+      throw new Error("計算距離矩陣時發生錯誤");
+    }
+  }
+
+  async getDirections(
+    origin: string,
+    destination: string,
+    mode: "driving" | "walking" | "bicycling" | "transit" = "driving"
+  ): Promise<{
+    routes: any[];
+    summary: string;
+    total_distance: { value: number; text: string };
+    total_duration: { value: number; text: string };
+  }> {
+    try {
+      const response = await this.client.directions({
+        params: {
+          origin: origin,
+          destination: destination,
+          mode: mode as TravelMode,
+          language: this.defaultLanguage,
+          key: process.env.GOOGLE_MAPS_API_KEY || "",
+        },
+      });
+
+      const result = response.data;
+
+      if (result.status !== "OK") {
+        throw new Error(`路線指引獲取失敗: ${result.status}`);
+      }
+
+      if (result.routes.length === 0) {
+        throw new Error("找不到路線");
+      }
+
+      const route = result.routes[0];
+      const legs = route.legs[0];
+
+      return {
+        routes: result.routes,
+        summary: route.summary,
+        total_distance: {
+          value: legs.distance.value,
+          text: legs.distance.text,
+        },
+        total_duration: {
+          value: legs.duration.value,
+          text: legs.duration.text,
+        },
+      };
+    } catch (error) {
+      console.error("Error in getDirections:", error);
+      throw new Error("獲取路線指引時發生錯誤");
+    }
+  }
+
+  async getElevation(locations: Array<{ latitude: number; longitude: number }>): Promise<Array<{ elevation: number; location: { lat: number; lng: number } }>> {
+    try {
+      const formattedLocations = locations.map((loc) => ({
+        lat: loc.latitude,
+        lng: loc.longitude,
+      }));
+
+      const response = await this.client.elevation({
+        params: {
+          locations: formattedLocations,
+          key: process.env.GOOGLE_MAPS_API_KEY || "",
+        },
+      });
+
+      const result = response.data;
+
+      if (result.status !== "OK") {
+        throw new Error(`海拔數據獲取失敗: ${result.status}`);
+      }
+
+      return result.results.map((item: any, index: number) => ({
+        elevation: item.elevation,
+        location: formattedLocations[index],
+      }));
+    } catch (error) {
+      console.error("Error in getElevation:", error);
+      throw new Error("獲取海拔數據時發生錯誤");
+    }
+  }
 }