TypeScript MCP Server Boilerplate

Instructions

Implementation Reference

• src/index.ts:307-488 (handler)

  The 'get-weather' tool is registered and implemented in src/index.ts, including its input schema and the asynchronous handler logic that calls the Open-Meteo API.

  server.registerTool(
      'get-weather',
      {
          description:
              '위도·경도와 예보 기간을 입력받아 현재 날씨와 일별 예보를 반환합니다. (Open-Meteo API 사용, API 키 불필요)',
          inputSchema: z.object({
              latitude: z
                  .number()
                  .min(-90)
                  .max(90)
                  .describe('위도 (WGS84, -90 ~ 90)'),
              longitude: z
                  .number()
                  .min(-180)
                  .max(180)
                  .describe('경도 (WGS84, -180 ~ 180)'),
              forecast_days: z
                  .number()
                  .int()
                  .min(1)
                  .max(16)
                  .optional()
                  .default(7)
                  .describe('예보 기간 (일 수, 기본값: 7, 최대: 16)'),
              temperature_unit: z
                  .enum(['celsius', 'fahrenheit'])
                  .optional()
                  .default('celsius')
                  .describe('온도 단위 (기본값: celsius)')
          }),
          outputSchema: z.object({
              content: z.array(
                  z.object({
                      type: z.literal('text'),
                      text: z.string().describe('날씨 요약 메시지')
                  })
              ),
              current: z.object({
                  time: z.string().describe('현재 시각'),
                  temperature: z.number().describe('현재 기온'),
                  apparentTemperature: z.number().describe('체감 기온'),
                  humidity: z.number().describe('상대 습도 (%)'),
                  weatherCode: z.number().describe('WMO 날씨 코드'),
                  weatherDescription: z.string().describe('날씨 설명'),
                  windSpeed: z.number().describe('풍속 (km/h)'),
                  precipitation: z.number().describe('강수량 (mm)'),
                  isDay: z.boolean().describe('낮 여부')
              }),
              daily: z.array(
                  z.object({
                      date: z.string().describe('날짜'),
                      weatherCode: z.number().describe('WMO 날씨 코드'),
                      weatherDescription: z.string().describe('날씨 설명'),
                      tempMax: z.number().describe('최고 기온'),
                      tempMin: z.number().describe('최저 기온'),
                      precipitationSum: z.number().describe('일 강수량 합계 (mm)'),
                      windSpeedMax: z.number().describe('최대 풍속 (km/h)')
                  })
              )
          })
      },
      async ({ latitude, longitude, forecast_days, temperature_unit }) => {
          const params = new URLSearchParams({
              latitude: String(latitude),
              longitude: String(longitude),
              current: [
                  'temperature_2m',
                  'apparent_temperature',
                  'relative_humidity_2m',
                  'weather_code',
                  'wind_speed_10m',
                  'precipitation',
                  'is_day'
              ].join(','),
              daily: [
                  'weather_code',
                  'temperature_2m_max',
                  'temperature_2m_min',
                  'precipitation_sum',
                  'wind_speed_10m_max'
              ].join(','),
              forecast_days: String(forecast_days),
              temperature_unit,
              wind_speed_unit: 'kmh',
              timezone: 'auto'
          })
  
          const response = await fetch(
              `https://api.open-meteo.com/v1/forecast?${params}`
          )
  
          if (!response.ok) {
              const err = (await response.json()) as { reason?: string }
              throw new Error(
                  `Open-Meteo API 오류: ${err.reason ?? response.statusText}`
              )
          }
  
          const data = (await response.json()) as {
              current: {
                  time: string
                  temperature_2m: number
                  apparent_temperature: number
                  relative_humidity_2m: number
                  weather_code: number
                  wind_speed_10m: number
                  precipitation: number
                  is_day: number
              }
              daily: {
                  time: string[]
                  weather_code: number[]
                  temperature_2m_max: number[]
                  temperature_2m_min: number[]
                  precipitation_sum: number[]
                  wind_speed_10m_max: number[]
              }
          }
  
          const unit = temperature_unit === 'fahrenheit' ? '°F' : '°C'
  
          const current = {
              time: data.current.time,
              temperature: data.current.temperature_2m,
              apparentTemperature: data.current.apparent_temperature,
              humidity: data.current.relative_humidity_2m,
              weatherCode: data.current.weather_code,
              weatherDescription: weatherCodeToDescription(
                  data.current.weather_code
              ),
              windSpeed: data.current.wind_speed_10m,
              precipitation: data.current.precipitation,
              isDay: data.current.is_day === 1
          }
  
          const daily = data.daily.time.map((date, i) => ({
              date,
              weatherCode: data.daily.weather_code[i],
              weatherDescription: weatherCodeToDescription(
                  data.daily.weather_code[i]
              ),
              tempMax: data.daily.temperature_2m_max[i],
              tempMin: data.daily.temperature_2m_min[i],
              precipitationSum: data.daily.precipitation_sum[i],
              windSpeedMax: data.daily.wind_speed_10m_max[i]
          }))
  
          const forecastLines = daily
              .map(
                  (d) =>
                      `  ${d.date}: ${d.weatherDescription}, 최고 ${d.tempMax}${unit} / 최저 ${d.tempMin}${unit}, 강수 ${d.precipitationSum}mm`
              )
              .join('\n')
  
          const message =
              `[현재 날씨] (${current.time})\n` +
              `  날씨: ${current.weatherDescription}\n` +
              `  기온: ${current.temperature}${unit} (체감 ${current.apparentTemperature}${unit})\n` +
              `  습도: ${current.humidity}%, 풍속: ${current.windSpeed}km/h, 강수: ${current.precipitation}mm\n\n` +
              `[${forecast_days}일 예보]\n` +
              forecastLines
  
          return {
              content: [
                  {
                      type: 'text' as const,
                      text: message
                  }
              ],
              structuredContent: {
                  content: [
                      {
                          type: 'text' as const,
                          text: message
                      }
                  ],
                  current,
                  daily
              }
          }
      }
  )