get_forecast

Instructions

Implementation Reference

• src/index.ts:78-152 (handler)

  The main handler function that implements the logic for the 'get_forecast' tool. It fetches grid point data, then forecast data from the National Weather Service API, formats the periods, and returns a text response.

  async ({ latitude, longitude }) => {
    // Get grid point data
    const pointsUrl = `${NWS_API_BASE}/points/${latitude.toFixed(4)},${longitude.toFixed(4)}`;
    const pointsData = await makeNWSRequest<PointsResponse>(pointsUrl);
  
    if (!pointsData) {
      return {
        content: [
          {
            type: "text",
            text: `Failed to retrieve grid point data for coordinates: ${latitude}, ${longitude}. This location may not be supported by the NWS API (only US locations are supported).`,
          },
        ],
      };
    }
  
    const forecastUrl = pointsData.properties?.forecast;
    if (!forecastUrl) {
      return {
        content: [
          {
            type: "text",
            text: "Failed to get forecast URL from grid point data",
          },
        ],
      };
    }
  
    // Get forecast data
    const forecastData = await makeNWSRequest<ForecastResponse>(forecastUrl);
    if (!forecastData) {
      return {
        content: [
          {
            type: "text",
            text: "Failed to retrieve forecast data",
          },
        ],
      };
    }
  
    const periods = forecastData.properties?.periods || [];
    if (periods.length === 0) {
      return {
        content: [
          {
            type: "text",
            text: "No forecast periods available",
          },
        ],
      };
    }
  
    // Format forecast periods
    const formattedForecast = periods.map((period: ForecastPeriod) =>
      [
        `${period.name || "Unknown"}:`,
        `Temperature: ${period.temperature || "Unknown"}°${period.temperatureUnit || "F"}`,
        `Wind: ${period.windSpeed || "Unknown"} ${period.windDirection || ""}`,
        `${period.shortForecast || "No forecast available"}`,
        "---",
      ].join("\n"),
    );
  
    const forecastText = `Forecast for ${latitude}, ${longitude}:\n\n${formattedForecast.join("\n")}`;
  
    return {
      content: [
        {
          type: "text",
          text: forecastText,
        },
      ],
    };
  },

• src/index.ts:70-77 (schema)

  Input schema for the get_forecast tool using Zod validation for latitude and longitude parameters.

  {
    latitude: z.number().min(-90).max(90).describe("Latitude of the location"),
    longitude: z
      .number()
      .min(-180)
      .max(180)
      .describe("Longitude of the location"),
  },

• src/index.ts:67-69 (registration)

  Registration of the 'get_forecast' tool on the MCP server, specifying name and description.

  server.tool(
    "get_forecast",
    "Get weather forecast for a location",

• src/weather-utils.ts:3-19 (helper)

  Helper utility function used in the get_forecast handler to perform API requests to the NWS with proper headers and error handling.

  export async function makeNWSRequest<T>(url: string): Promise<T | null> {
    const headers = {
      "User-Agent": USER_AGENT,
      Accept: "application/geo+json",
    };
  
    try {
      const response = await fetch(url, { headers });
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      return (await response.json()) as T;
    } catch (error) {
      console.error("Error making NWS request:", error);
      return null;
    }
  }

• src/weather-utils.ts:44-67 (schema)

  TypeScript interfaces defining the structure of NWS API responses used in the get_forecast tool (ForecastResponse, PointsResponse, ForecastPeriod).

  export interface ForecastPeriod {
    name?: string;
    temperature?: number;
    temperatureUnit?: string;
    windSpeed?: string;
    windDirection?: string;
    shortForecast?: string;
  }
  
  export interface AlertsResponse {
    features: AlertFeature[];
  }
  
  export interface PointsResponse {
    properties: {
      forecast?: string;
    };
  }
  
  export interface ForecastResponse {
    properties: {
      periods: ForecastPeriod[];
    };
  }