# Swiss Weather (pypi · swiss-weather-mcp)

Weather forecasts, measurements, snow, the avalanche bulletin and sun and moon times for Switzerland

- Trust score: 69/100 (medium)
- Change this week: +8
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- pypi · `swiss-weather-mcp`: 69/100 (this document), [markdown](https://verifymcp.io/servers/cuolm-swiss-weather-mcp/swiss-weather-mcp.md), [page](https://verifymcp.io/servers/cuolm-swiss-weather-mcp/swiss-weather-mcp)

## Channel facts

- Registry: `pypi`
- Package: `swiss-weather-mcp`
- Version: `0.5.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 50/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 1 of 34 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to cuolm/swiss-weather-mcp).
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 1 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 58/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 5779 tokens (~385/item across 15 items; 15 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 57/100
  - Stability observed for 17 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 80/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 30% of tool parameters carry a description.
  - Structured output schemas are declared (7% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 15 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 16 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the Swiss Weather MCP server?

Swiss Weather runs locally as a PyPI package, launched with uvx swiss-weather-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add cuolm-swiss-weather-mcp -- uvx swiss-weather-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "cuolm-swiss-weather-mcp": {
      "command": "uvx",
      "args": [
        "swiss-weather-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "cuolm-swiss-weather-mcp": {
      "command": "uvx",
      "args": [
        "swiss-weather-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add cuolm-swiss-weather-mcp -- uvx swiss-weather-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "cuolm-swiss-weather-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "swiss-weather-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add cuolm-swiss-weather-mcp --command uvx --arg swiss-weather-mcp
```

### Hermes

```yaml
mcp_servers:
  cuolm-swiss-weather-mcp:
    command: "uvx"
    args: ["swiss-weather-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "cuolm-swiss-weather-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "swiss-weather-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add cuolm-swiss-weather-mcp -t stdio -c uvx -a swiss-weather-mcp
```

### Other

```json
{
  "mcpServers": {
    "cuolm-swiss-weather-mcp": {
      "command": "uvx",
      "args": [
        "swiss-weather-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 69, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-20 (score 84, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-11-19 (score 68, −8)

- [security regression] Malware scan: pass → unverified
- [functional regression] Schema quality: 305 → 385
- [functional improvement] Stability: unverified → 0.50
- [functional] Package version: 0.4.0 → 0.5.0

### 2026-11-17 (score 76, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-16 (score 61, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-15 (score 76, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-13 (score 61, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-12 (score 76, +15)

- [security improvement] Malware scan: unverified → pass

## MCP tools (15)

### `forecast_daily` (~408 tokens)

Get the whole-day forecast at a place, for one day or several days in a row.

Use this for "how is the weather tomorrow" or "how is the weather at the weekend", and
for the total rain of a day. Each day covers a Swiss calendar day, 00:00 to 24:00 local
time. The minimum and maximum are the lowest and highest hourly mean temperature of
that day, and the weather words describe the daytime.

Args:
    location (str): Name of a place in Switzerland, e.g. "Zürich".
    start_date (str): The first day, e.g. "2026-09-23". Today or up to 8 days ahead.
    days (int): How many days in a row, from 1 to 9. Default 1.

Returns:
    dict: data_from when the forecast point is far away or at a significantly different
        height, the place, the model run and per day: date, weekday, lowest and highest
        temperature, rain median with its 10th and 90th percentile, weather symbol code,
        weather in words and emoji. In 8 of 10 possible outcomes, the day's rain lies between
        its 10th and 90th percentile. A value is None when MeteoSwiss does not publish it for
        the place.

Examples:
    forecast_daily("Zürich", "2026-09-23")
    forecast_daily("Zürich", "2026-09-26", 2)   # a weekend

Input parameters:

- `days` (integer)
- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.
- `start_date` (string, required)

### `forecast_rain` (~480 tokens)

Get when and how much it may rain at a place, and the weather in words, in 3-hour blocks
over a period.

Use this for "will it rain at 15:00" or "how is the weather this afternoon". Each block
covers the 3 hours between its from and to times
and gives the chance of rain, the median rainfall, how much the wettest hour may bring
(its 90th percentile) and the weather in words. The median is often 0 when showers are
possible, so read the chance and the "up to" amount as well. A period up to the end of
the forecast ends with its last full 3-hour block. Medians do not add up, so for the
total rain of a whole day use forecast_daily.

Args:
    location (str): Name of a place in Switzerland, e.g. "Zürich".
    start (str): Start of the period, a full hour, e.g. "2026-09-23T12:00". Today or up to 8 days ahead.
    end (str): End of the period, a full hour after start, e.g. "2026-09-23T18:00".

Returns:
    dict: data_from when the forecast point is far away or at a significantly different
        height, the place, the model run and per 3-hour block: from, to, chance of rain,
        median rainfall, wettest hour up to, weather in words and emoji.

Examples:
    forecast_rain("Zürich", "2026-09-23T15:00", "2026-09-23T18:00")    # 15:00
    forecast_rain("Zürich", "2026-09-23T12:00", "2026-09-23T18:00")    # the afternoon

Input parameters:

- `end` (string, required)
- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.
- `start` (string, required)

### `forecast_temperature` (~382 tokens)

Get the temperature hour by hour at a place, with its likely range.

Use this for "how warm is it at 15:00" or "how warm is it this afternoon". Without end
it returns the one hour starting at start. Each row gives the mean temperature of one
hour, between its from and to times.

Args:
    location (str): Name of a place in Switzerland, e.g. "Zürich".
    start (str): Start of the period, a full hour, e.g. "2026-09-23T15:00". Today or up to 8 days ahead.
    end (str): Optional. End of the period, a full hour after start, e.g. "2026-09-23T18:00".

Returns:
    dict: data_from when the forecast point is far away or at a significantly different
        height, the place, the model run and per hour: from, to, temperature with its 10th
        and 90th percentile. In 8 of 10 possible outcomes, the temperature lies between its
        10th and 90th percentile.

Examples:
    forecast_temperature("Zürich", "2026-09-23T15:00")                        # one hour
    forecast_temperature("Zürich", "2026-09-23T12:00", "2026-09-23T18:00")    # the afternoon

Input parameters:

- `end`
- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.
- `start` (string, required)

### `forecast_sunshine` (~327 tokens)

Get the sunshine hours at a place over a period.

Use this for "how sunny is it at 15:00" or "how sunny is it this afternoon". Without end
it returns the one hour starting at start.

Args:
    location (str): Name of a place in Switzerland, e.g. "Zürich".
    start (str): Start of the period, a full hour, e.g. "2026-09-23T06:00". Today or up to 8 days ahead.
    end (str): Optional. End of the period, a full hour after start, e.g. "2026-09-23T18:00".

Returns:
    dict: data_from when the forecast point is far away or at a significantly different
        height, the place, the period, the model run and the sunshine hours.

Examples:
    forecast_sunshine("Zürich", "2026-09-23T15:00")                        # one hour
    forecast_sunshine("Zürich", "2026-09-23T12:00", "2026-09-23T18:00")    # the afternoon

Input parameters:

- `end`
- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.
- `start` (string, required)

### `forecast_wind` (~340 tokens)

Get the wind at a place at a specific time: mean speed, strongest gust and direction.

Use this for "how windy is it at 14:00". The speed is the mean over the hour up to that
time, and the gust the strongest one-second gust in that hour. In 9 of 10 possible
outcomes the gust stays below its 90th percentile, so the percentile is a cautious high
estimate, not the highest gust possible. The direction is where the wind blows from, in
degrees clockwise from north (0 is a north wind, 180 a south wind) and as a compass
point.

Args:
    location (str): Name of a place in Switzerland, e.g. "Zürich".
    when (str): A full hour, e.g. "2026-09-23T14:00". Today or up to 8 days ahead.

Returns:
    dict: data_from when the forecast point is far away or at a significantly different
        height, the place, the valid time, the model run, mean speed, gust with its 90th
        percentile, direction in degrees and as compass point.

Examples:
    forecast_wind("Zürich", "2026-09-23T14:00")

Input parameters:

- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.
- `when` (string, required)

### `forecast_cloud_cover` (~286 tokens)

Get how cloudy it is at a place at a specific time.

Use this for "how cloudy is it at 14:00". MeteoSwiss publishes low, medium and high
cloud separately, and they overlap, so the total is an estimate that assumes the layers
are independent. All three layers are returned as well, so low cloud such as fog can be
told apart from high cloud.

Args:
    location (str): Name of a place in Switzerland, e.g. "Zürich".
    when (str): A full hour, e.g. "2026-09-23T14:00". Today or up to 8 days ahead.

Returns:
    dict: data_from when the forecast point is far away or at a significantly different
        height, the place, the valid time, the model run and the total cloud cover with its
        low, medium and high layers.

Examples:
    forecast_cloud_cover("Zürich", "2026-09-23T14:00")

Input parameters:

- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.
- `when` (string, required)

### `forecast_freezing_level` (~239 tokens)

Get the freezing level, the height of the 0 °C line, at a place at a specific time.

Use this for "how high is the freezing level at 14:00".

Args:
    location (str): Name of a place in Switzerland, e.g. "Zürich".
    when (str): A full hour, e.g. "2026-09-23T14:00". Today or up to 8 days ahead.

Returns:
    dict: data_from when the forecast point is far away or at a significantly different
        height, the place, the valid time, the model run and the freezing level above sea
        level.

Examples:
    forecast_freezing_level("Zürich", "2026-09-23T14:00")

Input parameters:

- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.
- `when` (string, required)

### `measurements_current` (~432 tokens)

Get the latest measurements of a MeteoSwiss station near a place.

Use this for "how warm is it now" or "is it raining now". The values are those of the
station named in data_from; without data_from, the station is next to the place.
MeteoSwiss publishes new values about every 10 minutes. When a station of the SLF, the
WSL Institute for Snow and Avalanche Research, is closer to the place in distance and
height, mostly in the mountains, slf_station adds its temperature, humidity and wind
over the last 30 minutes, with its own data_from. For each data_from, always say which
station the values come from, how far away it is and how much higher or lower. When
slf_station is there, give its values first, as they come from the closer station.

Args:
    location (str): Name of a place in Switzerland, e.g. "Zürich".

Returns:
    dict: data_from when the station is not next to the place, the place, the time of the
        measurements, temperature, humidity, dew point and sea-level pressure; wind speed, gust
        and direction of the last 10 minutes; rain and sunshine of the last 10 minutes and the
        last hour; strongest gust of the last hour; temperature and pressure change over 3
        hours. A value is None when the station has not published it. slf_station, only when
        an SLF station is closer: its data_from, time, temperature, humidity, wind speed,
        direction and gust over 30 minutes, and the snow surface temperature, None with less
        than 10 cm of snow.

Examples:
    measurements_current("Zürich")

Input parameters:

- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.

### `measurements_history` (~733 tokens)

Get the weather and the snow measured near a place on past days, for one day or several days in a row.

Use this for "how warm was it yesterday", "how much did it rain last week" or "how much snow was
there on this day last year". The weather comes from a MeteoSwiss station and the snow from a
MeteoSwiss or SLF station, each named in the data_from of its block; without data_from, the station
is next to the place. Each weather day covers a UTC day, 00:00 to 24:00 UTC, which is 01:00 to 01:00
Swiss time in winter and 02:00 to 02:00 in summer. When a station did not yet measure the rain per
UTC day, a day has rain_06_to_06_utc_mm instead of rain_mm: the rain from 06:00 UTC on the day to
06:00 UTC the next day. The snow depth is measured at 06:00 UTC on the day, and the new snow covers
the 24 hours from then. A day's values are published the next morning. The days go back to
when the station started, at some stations to the 1860s. For the warmest day of a year, ask for
all its days. For the same day in several years, call once per year. For each data_from, always
say which station the values come from, how far away it is and how much higher or lower.

Args:
    location (str): Name of a place in Switzerland, e.g. "Zürich".
    start_date (str): The first day, e.g. "2026-09-23". Yesterday or earlier; days from today
        on are left out.
    days (int): How many days in a row, from 1 to 366, so up to a whole year. Default 1.
    values (str): Optional. "weather" or "snow" for only one of them; without it, both.

Returns:
    dict: the place; weather: data_from when its station is not next to the place, and per day:
        date, weekday, mean, lowest and highest temperature, rain, sunshine hours and strongest
        gust; snow: data_from in the same way, and per day: date, snow depth and new snow. A value
        is None when the station did not measure it. snow is null when no snow station close
        enough in distance and height measured on the days.

Examples…

Input parameters:

- `days` (integer)
- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.
- `start_date` (string, required)
- `values`

### `measurements_snow` (~382 tokens)

Get the snow depth and the new snow near a place, from MeteoSwiss and SLF stations.

Use this for "how much snow is there in Davos" or "how much new snow fell in Zermatt".
Snow depth and new snow can come from two different stations, each named in its own
data_from unless it is next to the place. The snow depth comes from a MeteoSwiss station,
an automatic SLF station or an SLF observer; the new snow only from SLF, the WSL
Institute for Snow and Avalanche Research. An observer measures the new snow by hand each
morning, from November to April; at automatic stations, SLF calculates it from the snow
depth. Only stations close
enough in distance and height are used, so in the lowlands there is often no new snow.
When a block has data_from, always say which station the value comes from, how far away it
is and how much higher or lower.

Args:
    location (str): Name of a place in Switzerland, e.g. "Davos Dorf".

Returns:
    dict: the place, snow_depth and new_snow. snow_depth: data_from when its station is not
        next to the place, time and snow depth. new_snow: the same with the new snow of the
        last 24 hours and of the last 3 days.
        A block is null when no station close enough has a current value.

Examples:
    measurements_snow("Davos Dorf")

Input parameters:

- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.

### `measurements_extremes` (~495 tokens)

Get where in Switzerland it is warmest, coldest, windiest, wettest or sunniest now, or
where the snow is deepest or most new snow fell by this morning.

Use this for "where is it warmest now", "where is it sunny now", "where is the most snow"
or "where did it snow most last night". The values are those of about 160 MeteoSwiss
stations, so give the altitude with each station. For the sunniest, the stations are
grouped by their sun in the last 10 minutes with MeteoSwiss's sunshine terms: mostly
sunny (8 to 10 minutes), rather sunny (5 to 7), partly sunny (2 to 4), only a little
sunshine (1) and hardly any sunshine (0). The cantons come in order of their stations'
average sun, sunniest first. A station is rainy when it had rain in the last 10 minutes.
The snow is that of about 130 automatic SLF stations and the SLF manual sites at 06:00
UTC this morning, or yesterday's before SLF has published today's: the snow depth, and
the new snow of the 24 hours up to then. SLF calculates the new snow of its automatic
stations with a model, while observers measure it at the manual sites, so say which one
a value is. The deepest snow is mostly at the highest stations.

Args:
    extreme (str): One of "warmest", "coldest", "windiest", "wettest", "sunniest",
        "deepest_snow" or "most_new_snow".

Returns:
    dict: the time of the measurements and the first 5 stations, each with altitude, canton
        and value. For the sunniest instead the number of stations in each sunshine group, in
        Switzerland and in each canton, the sunniest canton first. For the wettest also the
        number of rainy stations out of those that measure rain, in Switzerland and in each
        canton. For the snow the stations with snow, each with its kind, and the number of
        stations with snow out of those that measured.

Examples:
    measurements_extremes("warmest")
    measurements_extremes("most_new_snow")

Input parameters:

- `extreme` (string, required)

### `avalanche_bulletin` (~438 tokens)

Get the SLF avalanche bulletin valid now for a place: the danger level, the avalanche problems
and SLF's texts.

Use this for "how high is the avalanche danger in Davos" or "can I go ski touring near
Engelberg". SLF, the WSL Institute for Snow and Avalanche Research, rates the danger from 1
low to 5 very high, from level 2 with a subdivision: - near the bottom, = in the middle and +
near the top of the level. Each avalanche problem applies only at its heights and on slopes
facing its aspects, often higher up than a village, so compare them with the place's altitude.
In spring, danger_level_later is the danger of the wet snow later in the day. In winter SLF
publishes the bulletin every day at 17:00, with an update at 08:00 when needed; in summer and
autumn only after heavy snowfall. Always give the source with its link.

Args:
    location (str): Name of a place in Switzerland, e.g. "Davos Dorf".

Returns:
    dict: the place and its altitude, the regions of the bulletin, when it was published, from
        when until when it is valid and its next update, the danger level, danger_level_later
        when the wet snow changes it later in the day, and the avalanche problems, each with its
        danger level, time of day, heights, aspects, summary and description. Then SLF's texts
        for all of Switzerland: snowpack, outlook, weather forecast and weather review (None when
        SLF gives none), a link to SLF's map of the bulletin and the source.

Examples:
    avalanche_bulletin("Davos Dorf")

Input parameters:

- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.

### `astronomy_sun` (~248 tokens)

Get when the Sun rises and sets at a place on a day, and when civil twilight begins and ends.

Use this for "when does the sun rise tomorrow" or "until when is it light tonight". Civil
twilight is the light before sunrise and after sunset; outside it, artificial light is
normally needed outdoors. The times are for a level horizon, so in a valley the Sun
appears later behind the mountains.

Args:
    location (str): Name of a place in Switzerland, e.g. "Zürich".
    date (str): The day, e.g. "2026-09-23".

Returns:
    dict: the place, the date, civil twilight begin, sunrise, sunset and civil twilight end.

Examples:
    astronomy_sun("Zürich", "2026-09-23")

Input parameters:

- `date` (string, required)
- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.

### `astronomy_moon` (~292 tokens)

Get when the Moon rises and sets at a place on a day, its phase and how much of it is lit.

Use this for "when does the moon rise tonight" or "how full is the moon tonight". The
times are for a level horizon, so in a valley the Moon appears later behind the
mountains. The day has a moon_phase_time when New Moon, First Quarter, Full Moon or Last
Quarter happens on it. The lit percent is the one at 12:00.

Args:
    location (str): Name of a place in Switzerland, e.g. "Zürich".
    date (str): The day, e.g. "2026-09-23".

Returns:
    dict: the place, the date, moonrise and moonset (None when the Moon does not rise or
        set that day), phase with emoji, phase time when a main phase falls on the day, and lit
        percent.

Examples:
    astronomy_moon("Zürich", "2026-09-23")

Input parameters:

- `date` (string, required)
- `location` (string, required)
- `near`: Only when several places share the name: a village next to the place the user means. For "the Blausee near Bettmeralp" use location "Blausee" and near "Bettmeralp". Leave it out otherwise.

### `current_date_and_time` (~139 tokens)

Get the current weekday and Swiss local time.

Call this first when the question is relative, such as "tomorrow" or "tonight", because
the forecast tools take a real date rather than an offset. Also call it before saying that a
date is in the future: your own idea of today may be out of date. The time is written the way
the tools read it, ISO 8601 without an offset, so it can be sent back to them as it is.

Returns:
    str: For example "Today is Wednesday, 2026-09-23T13:02 (Swiss time)".

Output parameters:

- `result` (string)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/cuolm-swiss-weather-mcp/swiss-weather-mcp#diagnostics

## Score history

- 2026-11-21: 69
- 2026-11-20: 84
- 2026-11-19: 68
- 2026-11-18: 76
- 2026-11-17: 76
- 2026-11-16: 61
- 2026-11-15: 76
- 2026-11-14: 61
- 2026-11-13: 61
- 2026-11-12: 76
- 2026-11-11: 61
- 2026-11-10: 76
- 2026-11-09: 76
- 2026-11-08: 61
- 2026-11-07: 61
- 2026-11-06: 61
- 2026-11-05: 61
- 2026-11-04: 61

## Common questions

### What is the Swiss Weather MCP server?

Swiss Weather is an MCP server listed in the public MCP registry as io.github.cuolm/swiss-weather-mcp. Weather forecasts, measurements, snow, the avalanche bulletin and sun and moon times for Switzerland. This page covers its PyPI package (swiss-weather-mcp).

### Is the Swiss Weather MCP server safe to use?

Swiss Weather scores 69 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Swiss Weather MCP server expose?

Swiss Weather exposes 15 tools: forecast_daily, forecast_rain, forecast_temperature, forecast_sunshine, forecast_wind, and 10 more. Their descriptions and schemas cost roughly 5,621 tokens of context every time the server is loaded.

### Is the Swiss Weather MCP server still maintained?

Swiss Weather is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Swiss Weather MCP server under?

Swiss Weather declares the Apache-2.0 licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the Swiss Weather MCP server?

VerifyMCP ran 15 checks on Swiss Weather, covering Known CVEs, Install scripts, Dependency health, Source repository and 11 more. One item could not be completed, a gap on our side rather than a finding about Swiss Weather: Malware scan. Endpoint Security and Transport & Reachability do not apply to a PyPI package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- PyPI project: https://pypi.org/project/swiss-weather-mcp/
- Socket report: https://socket.dev/pypi/package/swiss-weather-mcp
- Repository: https://github.com/cuolm/swiss-weather-mcp
- Changelog RSS feed: https://verifymcp.io/servers/cuolm-swiss-weather-mcp/swiss-weather-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/cuolm-swiss-weather-mcp/swiss-weather-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/cuolm-swiss-weather-mcp/swiss-weather-mcp.json
- HTML version of this page: https://verifymcp.io/servers/cuolm-swiss-weather-mcp/swiss-weather-mcp
