get-directions

Instructions

Implementation Reference

• src/maps.ts:331-397 (handler)

  The handler function for the 'get-directions' tool. It uses the Google Maps Directions API to compute routes between origin and destination, extracts route data including steps, formats it using formatDirectionsToMarkdown, and returns as Markdown text content.

  export async function getDirections(
    params: z.infer<typeof directionsSchema>,
    extra?: any
  ) {
    const apiKey = process.env.GOOGLE_MAPS_API_KEY;
    if (!apiKey) {
      throw new Error("GOOGLE_MAPS_API_KEY is required");
    }
  
    try {
      const response = await googleMapsClient.directions({
        params: {
          origin: params.origin,
          destination: params.destination,
          mode: (params.mode || "driving") as any,
          key: apiKey,
        },
      });
  
      const routes = response.data.routes;
      if (routes.length === 0) {
        return {
          content: [
            {
              type: "text" as const,
              text: "No routes found between the given locations.",
            },
          ],
        };
      }
  
      const route = routes[0];
      const leg = route.legs[0];
  
      const routeData = {
        distance: leg.distance.text,
        duration: leg.duration.text,
        start_address: leg.start_address,
        end_address: leg.end_address,
        steps: leg.steps.map((step) => ({
          instruction: step.html_instructions.replace(/<[^>]*>/g, ""),
          distance: step.distance.text,
          duration: step.duration.text,
        })),
      };
  
      return {
        content: [
          {
            type: "text" as const,
            text: formatDirectionsToMarkdown(routeData),
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text" as const,
            text: `Error getting directions: ${
              error instanceof Error ? error.message : String(error)
            }`,
          },
        ],
      };
    }
  }

• src/maps.ts:123-130 (schema)

  Zod schema defining the input parameters for the get-directions tool: origin (string), destination (string), and optional mode (enum: driving, walking, bicycling, transit).

  export const directionsSchema = z.object({
    origin: z.string().describe("Starting location (address or lat,lng)"),
    destination: z.string().describe("Ending location (address or lat,lng)"),
    mode: z
      .enum(["driving", "walking", "bicycling", "transit"])
      .optional()
      .describe("Travel mode"),
  });

• src/index.ts:89-97 (registration)

  Registration of the 'get-directions' tool using McpServer.tool(), providing name, description, input schema from directionsSchema.shape, and handler that calls getDirections.

  // Directions tool
  server.tool(
    "get-directions",
    "Get directions between two locations",
    directionsSchema.shape,
    async (params) => {
      return await getDirections(params);
    }
  );

• src/maps.ts:40-53 (helper)

  Helper function to format the directions route data (distance, duration, steps) into a structured Markdown string for the tool response.

  function formatDirectionsToMarkdown(route: any): string {
    let markdown = `# Directions: ${route.start_address} → ${route.end_address}\n\n`;
    markdown += `Distance: ${route.distance}  \n`;
    markdown += `Duration: ${route.duration}  \n\n`;
    
    if (route.steps && route.steps.length) {
      markdown += `## Step-by-Step Directions\n\n`;
      route.steps.forEach((step: any, index: number) => {
        markdown += `${index + 1}. ${step.instruction} *(${step.distance}, ${step.duration})*\n`;
      });
    }
    
    return markdown;
  }