Skip to main content
Glama
masx200

AMap Maps MCP Server

by masx200

maps_direction_transit_integrated

Plan public transit routes using integrated transportation modes (bus, subway, train) between specified coordinates and cities, returning detailed commuting options.

Instructions

公交路径规划 API 可以根据用户起终点经纬度坐标规划综合各类公共(火车、公交、地铁)交通方式的通勤方案,并且返回通勤方案的数据,跨城场景下必须传起点城市与终点城市

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
originYes出发点经度,纬度,坐标格式为:经度,纬度
destinationYes目的地经度,纬度,坐标格式为:经度,纬度
cityYes公共交通规划起点城市
citydYes公共交通规划终点城市

Implementation Reference

  • The core handler function that executes the tool logic: constructs the Amap API URL for transit integrated directions, fetches data, handles errors, and formats the complex response structure for output.
    async function handleTransitIntegrated(
      origin,
      destination,
      city = "",
      cityd = "",
    ) {
      const url = new URL(
        "https://restapi.amap.com/v3/direction/transit/integrated",
      );
      url.searchParams.append("key", AMAP_MAPS_API_KEY);
      url.searchParams.append("origin", origin);
      url.searchParams.append("destination", destination);
      url.searchParams.append("city", city);
      url.searchParams.append("cityd", cityd);
      url.searchParams.append("source", "ts_mcp");
      const response = await fetch(url.toString());
      const data = await response.json();
      if (data.status !== "1") {
        return {
          content: [{
            type: "text",
            text: `Direction Transit Integrated failed: ${
              data.info || data.infocode
            }`,
          }],
          isError: true,
        };
      }
      return {
        content: [{
          type: "text",
          text: JSON.stringify(
            {
              route: {
                origin: data.route.origin,
                destination: data.route.destination,
                distance: data.route.distance,
                transits: data.route.transits
                  ? data.route.transits.map((transit) => {
                    return {
                      duration: transit.duration,
                      walking_distance: transit.walking_distance,
                      segments: transit.segments
                        ? transit.segments.map((segment) => {
                          return {
                            walking: {
                              origin: segment.walking.origin,
                              destination: segment.walking.destination,
                              distance: segment.walking.distance,
                              duration: segment.walking.duration,
                              steps: segment.walking && segment.walking.steps
                                ? segment.walking.steps.map((step) => {
                                  return {
                                    instruction: step.instruction,
                                    road: step.road,
                                    distance: step.distance,
                                    action: step.action,
                                    assistant_action: step.assistant_action,
                                  };
                                })
                                : [],
                            },
                            bus: {
                              buslines: segment.bus && segment.bus.buslines
                                ? segment.bus.buslines.map((busline) => {
                                  return {
                                    name: busline.name,
                                    departure_stop: {
                                      name: busline.departure_stop.name,
                                    },
                                    arrival_stop: {
                                      name: busline.arrival_stop.name,
                                    },
                                    distance: busline.distance,
                                    duration: busline.duration,
                                    via_stops: busline.via_stops
                                      ? busline.via_stops.map((via_stop) => {
                                        return {
                                          name: via_stop.name,
                                        };
                                      })
                                      : [],
                                  };
                                })
                                : [],
                            },
                            entrance: {
                              name: segment.entrance.name,
                            },
                            exit: {
                              name: segment.exit.name,
                            },
                            railway: {
                              name: segment.railway.name,
                              trip: segment.railway.trip,
                            },
                          };
                        })
                        : [],
                    };
                  })
                  : [],
              },
            },
            null,
            2,
          ),
        }],
        isError: false,
      };
    }
  • The tool's metadata and input schema definition, used for listing tools and input validation.
    const TRANSIT_INTEGRATED_TOOL = {
      name: "maps_direction_transit_integrated",
      description:
        "公交路径规划 API 可以根据用户起终点经纬度坐标规划综合各类公共(火车、公交、地铁)交通方式的通勤方案,并且返回通勤方案的数据,跨城场景下必须传起点城市与终点城市",
      inputSchema: {
        type: "object",
        properties: {
          origin: {
            type: "string",
            description: "出发点经度,纬度,坐标格式为:经度,纬度",
          },
          destination: {
            type: "string",
            description: "目的地经度,纬度,坐标格式为:经度,纬度",
          },
          city: {
            type: "string",
            description: "公共交通规划起点城市",
          },
          cityd: {
            type: "string",
            description: "公共交通规划终点城市",
          },
        },
        required: ["origin", "destination", "city", "cityd"],
      },
    };
  • build/index.js:886-889 (registration)
    Registration in the switch statement of the CallToolRequestSchema handler, dispatching calls to the tool's handler function.
    case "maps_direction_transit_integrated": {
      const { origin, destination, city, cityd } = request.params.arguments;
      return await handleTransitIntegrated(origin, destination, city, cityd);
    }
  • build/index.js:848-850 (registration)
    Registration of ListToolsRequestSchema handler that returns the list of tools including this one via MAPS_TOOLS array.
    server.setRequestHandler(ListToolsRequestSchema, async () => ({
      tools: MAPS_TOOLS,
    }));
  • Identical core handler function in the HTTP server version, executes the same Amap API logic.
    async function handleTransitIntegrated(
      origin,
      destination,
      city = "",
      cityd = "",
    ) {
      const AMAP_MAPS_API_KEY = getApiKey();
      const url = new URL(
        "https://restapi.amap.com/v3/direction/transit/integrated",
      );
      url.searchParams.append("key", AMAP_MAPS_API_KEY);
      url.searchParams.append("origin", origin);
      url.searchParams.append("destination", destination);
      url.searchParams.append("city", city);
      url.searchParams.append("cityd", cityd);
      url.searchParams.append("source", "ts_mcp");
      const response = await fetch(url.toString());
      const data = await response.json();
      if (data.status !== "1") {
        return {
          content: [
            {
              type: "text",
              text: `Direction Transit Integrated failed: ${
                data.info || data.infocode
              }`,
            },
          ],
          isError: true,
        };
      }
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(
              {
                route: {
                  origin: data.route.origin,
                  destination: data.route.destination,
                  distance: data.route.distance,
                  transits: data.route.transits
                    ? data.route.transits.map((transit) => {
                      return {
                        duration: transit.duration,
                        walking_distance: transit.walking_distance,
                        segments: transit.segments
                          ? transit.segments.map((segment) => {
                            return {
                              walking: {
                                origin: segment.walking.origin,
                                destination: segment.walking.destination,
                                distance: segment.walking.distance,
                                duration: segment.walking.duration,
                                steps: segment.walking && segment.walking.steps
                                  ? segment.walking.steps.map((step) => {
                                    return {
                                      instruction: step.instruction,
                                      road: step.road,
                                      distance: step.distance,
                                      action: step.action,
                                      assistant_action: step.assistant_action,
                                    };
                                  })
                                  : [],
                              },
                              bus: {
                                buslines: segment.bus && segment.bus.buslines
                                  ? segment.bus.buslines.map((busline) => {
                                    return {
                                      name: busline.name,
                                      departure_stop: {
                                        name: busline.departure_stop.name,
                                      },
                                      arrival_stop: {
                                        name: busline.arrival_stop.name,
                                      },
                                      distance: busline.distance,
                                      duration: busline.duration,
                                      via_stops: busline.via_stops
                                        ? busline.via_stops.map(
                                          (via_stop) => {
                                            return {
                                              name: via_stop.name,
                                            };
                                          },
                                        )
                                        : [],
                                    };
                                  })
                                  : [],
                              },
                              entrance: {
                                name: segment.entrance.name,
                              },
                              exit: {
                                name: segment.exit.name,
                              },
                              railway: {
                                name: segment.railway.name,
                                trip: segment.railway.trip,
                              },
                            };
                          })
                          : [],
                      };
                    })
                    : [],
                },
              },
              null,
              2,
            ),
          },
        ],
        isError: false,
      };
    }

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/masx200/amap-maps-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server