Build an MCP Server with Weather tools using Express and Vercel

1
vc init express express-mcp-weather
2
cd express-mcp-weather

1
  "dependencies": {
2
    "express": "^5.1.0",
3
    "mcp-handler": "^1.0.3",
4
    "zod": "3.23.8"
5
  },

1
import express from 'express';
2

3
const app = express();
4
const PORT = process.env.PORT || 3000;
5

6
app.use(express.json());
7

8
app.get('/api/weather/:city', async (req, res) => {
9
  try {
10
    const city = req.params.city;
11
    const units = req.query.units as string | undefined;
12
    
13
    // Normalize units parameter
14
    const normalizedUnits = units === 'imperial' ? 'imperial' : 'metric';
15
    
16
    // Step 1: Geocode city to get coordinates
17
    const geoParams = new URLSearchParams({
18
      name: city,
19
      count: '1',
20
      language: 'en',
21
      format: 'json'
22
    });
23
    
24
    const geoResponse = await fetch(`https://geocoding-api.open-meteo.com/v1/search?${geoParams}`);
25
    
26
    if (!geoResponse.ok) {
27
      return res.status(geoResponse.status).json({ 
28
        error: 'Failed to fetch geocoding data' 
29
      });
30
    }
31
    
32
    const geoData = await geoResponse.json();
33
    
34
    if (!geoData.results || geoData.results.length === 0) {
35
      return res.status(404).json({ error: `City '${city}' not found` });
36
    }
37
    
38
    const location = geoData.results[0];
39
    const { name, country, latitude, longitude } = location;
40
    
41
    // Step 2: Fetch current weather data
42
    const weatherParams: Record<string, string> = {
43
      latitude: latitude.toString(),
44
      longitude: longitude.toString(),
45
      current: 'temperature_2m,relative_humidity_2m,apparent_temperature,wind_speed_10m',
46
      timezone: 'auto'
47
    };
48
    
49
    // Add unit parameters for imperial if needed
50
    if (units === 'imperial') {
51
      weatherParams.temperature_unit = 'fahrenheit';
52
      weatherParams.wind_speed_unit = 'mph';
53
    }
54
    
55
    const weatherUrlParams = new URLSearchParams(weatherParams);
56
    const weatherResponse = await fetch(`https://api.open-meteo.com/v1/forecast?${weatherUrlParams}`);
57
    
58
    if (!weatherResponse.ok) {
59
      return res.status(weatherResponse.status).json({ 
60
        error: 'Failed to fetch weather data' 
61
      });
62
    }
63
    
64
    const weatherData = await weatherResponse.json();
65
    
66
    // Return structured weather data
67
    res.json({
68
      city: name,
69
      country,
70
      latitude,
71
      longitude,
72
      units: normalizedUnits,
73
      current: weatherData.current
74
    });
75
    
76
  } catch (error) {
77
    console.error('Weather API error:', error);
78
    res.status(500).json({ 
79
      error: 'Failed to fetch weather data',
80
      message: error instanceof Error ? error.message : 'Unknown error'
81
    });
82
  }
83
});

1
vercel dev

1
# Test with default metric units
2
curl http://localhost:3000/api/weather/london
3

4
# Test with imperial units
5
curl "http://localhost:3000/api/weather/san%20francisco?units=imperial"

1
// This goes at the top of the file
2
import { z } from 'zod';
3
import { createMcpHandler } from 'mcp-handler';
4

5
// This goes below the weather endpoint, 
6
// Helper function: Call your own Express API
7
async function callWeatherAPI(
8
  city: string,
9
  units: 'metric' | 'imperial' = 'metric'
10
) {
11
  const response = await fetch(
12
    `http://localhost:${PORT}/api/weather/${city}?units=${units}`
13
  );
14

15
  if (!response.ok) {
16
    const error = await response.json();
17
    throw new Error(error.error || 'Failed to fetch weather');
18
  }
19

20
  return await response.json();
21
}
22

23
// Create MCP handler with tools
24
const mcpHandler = createMcpHandler(
25
  (server) => {
26
    // Tool 1: Get Temperature
27
    server.tool(
28
      'get_temperature',
29
      'Get current temperature and "feels like" temperature for a city',
30
      {
31
        city: z.string().describe('City name (e.g., "London", "Tokyo")'),
32
        units: z.enum(['metric', 'imperial'])
33
          .optional()
34
          .describe('metric (Celsius) or imperial (Fahrenheit)')
35
      },
36
      async ({ city, units = 'metric' }) => {
37
        try {
38
          const data = await callWeatherAPI(city, units);
39
          const tempUnit = units === 'imperial' ? '°F' : '°C';
40

41
          return {
42
            content: [{
43
              type: 'text',
44
              text: `Temperature in ${data.city}, ${data.country}:
45
- Current: ${data.current.temperature_2m}${tempUnit}
46
- Feels like: ${data.current.apparent_temperature}${tempUnit}`
47
            }]
48
          };
49
        } catch (error) {
50
          return {
51
            content: [{
52
              type: 'text',
53
              text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
54
            }],
55
            isError: true
56
          };
57
        }
58
      }
59
    );
60

61
    // Tool 2: Get Humidity
62
    server.tool(
63
      'get_humidity',
64
      'Get current relative humidity for a city',
65
      {
66
        city: z.string().describe('City name (e.g., "London", "Tokyo")')
67
      },
68
      async ({ city }) => {
69
        try {
70
          const data = await callWeatherAPI(city, 'metric');
71

72
          return {
73
            content: [{
74
              type: 'text',
75
              text: `Humidity in ${data.city}, ${data.country}:
76
- Relative Humidity: ${data.current.relative_humidity_2m}%`
77
            }]
78
          };
79
        } catch (error) {
80
          return {
81
            content: [{
82
              type: 'text',
83
              text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
84
            }],
85
            isError: true
86
          };
87
        }
88
      }
89
    );
90

91
    // Tool 3: Get Wind Speed
92
    server.tool(
93
      'get_wind_speed',
94
      'Get current wind speed for a city',
95
      {
96
        city: z.string().describe('City name (e.g., "London", "Tokyo")'),
97
        units: z.enum(['metric', 'imperial'])
98
          .optional()
99
          .describe('metric (km/h) or imperial (mph)')
100
      },
101
      async ({ city, units = 'metric' }) => {
102
        try {
103
          const data = await callWeatherAPI(city, units);
104
          const speedUnit = units === 'imperial' ? 'mph' : 'km/h';
105

106
          return {
107
            content: [{
108
              type: 'text',
109
              text: `Wind Speed in ${data.city}, ${data.country}:
110
- Current: ${data.current.wind_speed_10m} ${speedUnit}`
111
            }]
112
          };
113
        } catch (error) {
114
          return {
115
            content: [{
116
              type: 'text',
117
              text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
118
            }],
119
            isError: true
120
          };
121
        }
122
      }
123
    );
124

125
    // Tool 4: Get Full Weather
126
    server.tool(
127
      'get_full_weather',
128
      'Get complete weather information for a city',
129
      {
130
        city: z.string().describe('City name (e.g., "London", "Tokyo")'),
131
        units: z.enum(['metric', 'imperial'])
132
          .optional()
133
          .describe('metric or imperial units')
134
      },
135
      async ({ city, units = 'metric' }) => {
136
        try {
137
          const data = await callWeatherAPI(city, units);
138
          const tempUnit = units === 'imperial' ? '°F' : '°C';
139
          const speedUnit = units === 'imperial' ? 'mph' : 'km/h';
140

141
          return {
142
            content: [{
143
              type: 'text',
144
              text: `Weather for ${data.city}, ${data.country}:
145

146
📍 Location: ${data.latitude}, ${data.longitude}
147
🌡️ Temperature: ${data.current.temperature_2m}${tempUnit} (feels like ${data.current.apparent_temperature}${tempUnit})
148
💧 Humidity: ${data.current.relative_humidity_2m}%
149
💨 Wind: ${data.current.wind_speed_10m} ${speedUnit}
150
🕐 Updated: ${data.current.time}`
151
            }]
152
          };
153
        } catch (error) {
154
          return {
155
            content: [{
156
              type: 'text',
157
              text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
158
            }],
159
            isError: true
160
          };
161
        }
162
      }
163
    );
164
  },
165
  {},
166
  { basePath: '/api' }
167
);
168

1
// Helper: Convert Express request to Web Request
2
function toWebRequest(req: express.Request): Request {
3
  const url = `http://${req.headers.host}${req.url}`;
4
  return new Request(url, {
5
    method: req.method,
6
    headers: req.headers as HeadersInit,
7
    body: req.method !== 'GET' && req.method !== 'HEAD'
8
      ? JSON.stringify(req.body)
9
      : undefined,
10
  });
11
}
12

13
// Mount MCP handler with proper conversion
14
app.all('/api/mcp', async (req, res) => {
15
  try {
16
    const webRequest = toWebRequest(req);
17
    const webResponse = await mcpHandler(webRequest);
18

19
    // Convert Web Response back to Express response
20
    res.status(webResponse.status);
21
    webResponse.headers.forEach((value, key) => {
22
      res.setHeader(key, value);
23
    });
24

25
    const body = await webResponse.text();
26
    res.send(body);
27
  } catch (error) {
28
    console.error('MCP handler error:', error);
29
    res.status(500).json({ error: 'Internal server error' });
30
  }
31
});

1
curl -X POST http://localhost:3000/api/mcp \
2
  -H "Content-Type: application/json" \
3
  -H "Accept: application/json, text/event-stream" \
4
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

1
npx @modelcontextprotocol/inspector@latest http://localhost:3000

1
{
2
  "mcpServers": {
3
    "weather": {
4
      "url": "http://localhost:3000/api/mcp"
5
    }
6
  }
7
}

1
{
2
  "mcpServers": {
3
    "weather": {
4
      "url": "<https://your-app.vercel.app/api/mcp>"
5
    }
6
  }
7
}