Skip to main content
Glama
swiss-road-mobility-mcp
by malkreide

🇨🇭 Part of the Swiss Public Data MCP Portfolio

🚗 Swiss Road & Mobility MCP Server

Version License: MIT Python 3.11+ MCP CI

MCP Server for Swiss road mobility — shared vehicles, EV charging, traffic alerts, Park & Rail, and multimodal trip planning

🇩🇪 Deutsche Version


Demo

Demo: Claude using road_mobility_snapshot at Zürich HB


Related MCP server: swiss-rail-mcp

Overview

swiss-road-mobility-mcp provides AI-native access to Swiss road and mobility data sources:

Source

Data

API

Auth

sharedmobility.ch

Bikes, e-scooters, cars (GBFS)

REST/JSON

None

ich-tanke-strom.ch

EV charging stations

GeoJSON

None

opentransportdata.swiss

Traffic events, counting stations

DATEX II / SOAP+XML

Free key

data.sbb.ch

Park & Rail facilities

REST/JSON (Opendatasoft)

None

transport.opendata.ch

Public transport connections

REST/JSON

None

geo.admin.ch

Address geocoding, road classification

REST/JSON

None

If the Swiss Transport MCP is the GA pass for rail, this server is the vignette + Park & Rail card + sharing subscription for the road — together they paint the complete multimodal picture of Swiss mobility.

Anchor demo query: "I'm in Dietikon with my car. I need to get to Bern. Where can I park? Which train should I take?"


Features

  • 15 tools across six data sources (Phase 1–4)

  • road_mobility_snapshot — aggregated mobility overview for any location

  • road_multimodal_plan — car + Park & Rail + public transport in one plan

  • No API key required for 12 of 15 tools

  • Dual transport — stdio (Claude Desktop) + SSE (cloud)

  • Rate limiting + caching for all endpoints


Prerequisites

  • Python 3.11+

  • uv (recommended) or pip


Installation

# Clone the repository
git clone https://github.com/malkreide/swiss-road-mobility-mcp.git
cd swiss-road-mobility-mcp

# Install
pip install -e .
# or with uv:
uv pip install -e .

Or with uvx (no permanent installation):

uvx swiss-road-mobility-mcp

Quickstart

# stdio (for Claude Desktop)
swiss-road-mobility-mcp
# or:
python -m swiss_road_mobility_mcp.server

# Streamable HTTP (for cloud / Render.com) — serves MCP 2026-07-28 at /mcp
# and keeps the legacy SSE routes alongside.
MCP_TRANSPORT=http MCP_PORT=8001 swiss-road-mobility-mcp

Try it immediately in Claude Desktop:

"Show me everything mobility-related at Zurich HB." "Find shared bikes near Bern Bahnhof." "Where can I charge my EV near Lucerne?"

→ More use cases by audience →


Configuration

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "swiss-road-mobility": {
      "command": "uvx",
      "args": ["swiss-road-mobility-mcp"],
      "env": {
        "OPENTRANSPORTDATA_API_KEY": "<your-token>"
      }
    }
  }
}

Or with python:

{
  "mcpServers": {
    "swiss-road-mobility": {
      "command": "python",
      "args": ["-m", "swiss_road_mobility_mcp.server"],
      "env": {
        "OPENTRANSPORTDATA_API_KEY": "<your-token>"
      }
    }
  }
}

Shared mobility, EV charging, Park & Rail, and the multimodal planner work without an OPENTRANSPORTDATA_API_KEY. The key is only required for the DATEX II traffic tools.

Config file locations:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

Cloud Deployment (SSE for browser access)

For use via claude.ai in the browser (e.g. on managed workstations without local software):

Render.com (recommended):

  1. Push/fork the repository to GitHub

  2. On render.com: New Web Service -> connect GitHub repo

  3. Set start command: MCP_TRANSPORT=http MCP_PORT=8001 swiss-road-mobility-mcp

  4. In claude.ai under Settings -> MCP Servers, add https://your-app.onrender.com/mcp — or .../sse for a client that still speaks the SSE transport; http serves both.

SSE security (SEC-009)

A public SSE endpoint is reachable by anyone. To protect it (and your upstream API quota), configure these environment variables on the host:

Variable

Effect

MCP_AUTH_TOKEN

When set, every SSE request must send Authorization: Bearer <token>. Unset = unauthenticated (the server logs a loud warning at startup). Strongly recommended for any public deployment.

MCP_RATE_LIMIT

Max requests per client IP per window (default 60, 0 disables).

MCP_RATE_WINDOW

Window length in seconds (default 60).

ALLOWED_ORIGINS

Comma-separated CORS origins for browser clients. Empty by default: no cross-origin access. * allows any origin and is logged as a warning. Does not affect stdio or other non-browser clients.

The local stdio transport needs none of this — it runs in the user's trusted context.

Observability (OBS-003 / OBS-006)

Variable

Effect

MCP_LOG_LEVEL

Log level: DEBUG / INFO (default) / WARNING / ERROR.

MCP_LOG_FORMAT

text (default) or json for structured logs. All logs go to stderr.

MCP_TRACING_ENABLED

true enables OpenTelemetry tracing (off by default).

OTEL_EXPORTER_OTLP_ENDPOINT

OTLP collector URL; setting it also enables tracing. Standard OTEL_* vars are honoured by the SDK.

Tracing needs the optional extra: pip install 'swiss-road-mobility-mcp[tracing]'. Once enabled, every upstream API call is traced automatically (httpx instrumentation) and SSE requests get server spans with W3C trace-context propagation.


Available Tools

Shared Mobility & EV Charging (no API key required)

Tool

Description

Cache

road_find_sharing

Shared mobility nearby (bikes, e-scooters, cars)

60s

road_search_sharing

Search sharing stations by name

5min

road_sharing_providers

All sharing providers in Switzerland

1h

road_find_charger

EV charging stations nearby

5min

road_charger_status

Real-time availability of charging stations

1min

road_check_status

Server & API health check

-

Traffic (free API key required)

Tool

Description

Cache

road_traffic_situations

Accidents, roadworks, congestion from ASTRA/VMZ-CH

2min

road_traffic_counters

Vehicles/h + km/h at counting stations near a position

1min

road_counter_sites

List counting stations nearby

24h

Park & Rail + Multimodal (no API key required)

Tool

Description

Cache

road_park_rail

Find SBB Park+Rail facilities nearby

5min

road_mobility_snapshot

Complete mobility overview for a location

-

road_multimodal_plan

Plan car -> Park+Rail -> public transport -> destination

-

Geography & Addresses — Phase 4 (no API key required)

Tool

Description

Cache

road_geocode_address

Swiss address -> GPS (official building address register)

-

road_reverse_geocode

GPS -> official address with EGID/EGAID (GWR)

-

road_classify_road

Road classification via swissTLM3D

-

Example Use Cases

Query

Tool

"Find shared bikes near Zurich HB"

road_find_sharing

"Where can I charge my EV near Bern?"

road_find_charger

"Any traffic incidents on the A1?"

road_traffic_situations

"Where can I park near Winterthur station?"

road_park_rail

"Plan my trip from Dietikon to Bern by car + train"

road_multimodal_plan


API Key for Traffic Tools

  1. Register: https://api-manager.opentransportdata.swiss

  2. Create a new application -> subscribe to the "Strassenverkehr" API

  3. Copy the token

export OPENTRANSPORTDATA_API_KEY=<your-token>

Without a key, the traffic tools return a descriptive error message including the exact registration link — no crash.


Architecture

swiss_road_mobility_mcp/
├── server.py             # FastMCP server, 15 tools
├── api_infrastructure.py # Rate limiter, cache, HTTP client, geo utilities
├── shared_mobility.py    # sharedmobility.ch
├── ev_charging.py        # ich-tanke-strom.ch
├── traffic_situations.py # DATEX II traffic alerts (SOAP/XML)
├── traffic_counters.py   # DATEX II counting stations (SOAP/XML)
├── park_rail.py          # SBB Open Data Park & Rail
├── multimodal.py         # Snapshot + trip planner (cross-source)
└── geo_admin.py          # geo.admin.ch geocoding + road classification

Data Source Characteristics

Source

Protocol

Coverage

Auth

sharedmobility.ch

REST/JSON (GBFS)

All CH sharing providers

None

ich-tanke-strom.ch

GeoJSON

All public EV chargers

None

opentransportdata.swiss

DATEX II / SOAP+XML

ASTRA traffic data

Free key

data.sbb.ch

REST/JSON (Opendatasoft)

SBB Park & Rail

None

transport.opendata.ch

REST/JSON

Public transport schedules

None

geo.admin.ch

REST/JSON

Official addresses, roads

None

In-depth docs: docs/ARCHITECTURE.md (MCP primitives, tool namespacing, use-case catalogue, phase roadmap) · docs/SECURITY.md (credential model, egress allow-list, auth, MCP conformance table) · docs/OPERATIONS.md (resource limits, restart policy, health).


Project Structure

swiss-road-mobility-mcp/
├── src/swiss_road_mobility_mcp/
│   ├── __init__.py              # Package
│   ├── server.py                # FastMCP server, 15 tools
│   ├── api_infrastructure.py    # Rate limiter, cache, HTTP client
│   ├── shared_mobility.py       # Shared vehicles
│   ├── ev_charging.py           # EV charging stations
│   ├── traffic_situations.py    # Traffic events
│   ├── traffic_counters.py      # Vehicle counting
│   ├── park_rail.py             # Park & Rail
│   ├── multimodal.py            # Snapshot + trip planning
│   └── geo_admin.py             # Geocoding + roads
├── tests/
│   ├── test_integration.py      # Live API tests
│   └── test_phase3.py           # Park & Rail + multimodal tests
├── .github/workflows/ci.yml     # GitHub Actions (Python 3.11/3.12/3.13)
├── pyproject.toml
├── CHANGELOG.md
├── CONTRIBUTING.md               # Contribution guide (English)
├── CONTRIBUTING.de.md            # Contribution guide (German)
├── SECURITY.md                   # Security policy (English)
├── SECURITY.de.md                # Security policy (German)
├── LICENSE
├── README.md                    # This file (English)
└── README.de.md                 # German version

Known Limitations

  • Shared Mobility: The sharedmobility.ch API does not enforce strict radius filtering; vehicles slightly outside the specified radius may appear

  • EV Charging: Station naming conventions vary between operators; some stations may appear without detailed names

  • Traffic (DATEX II): Requires a free API key; without it, traffic tools return helpful error messages

  • Park & Rail: SBB occasionally renames endpoints; the server includes a fallback chain

  • Multimodal Planner: Response time depends on the slowest of the queried sources


MCP Protocol Version

This server speaks two protocol eras. The client's first request on a connection decides which one applies; a later claim from the other era is refused.

Era

Revision

Who reaches it

initialize handshake

2024-11-05 … 2025-11-25

What today's clients speak. The server answers with the revision asked for, or with the 2025-11-25 ceiling when the request asks for something newer.

Per-request envelope

2026-07-28

A request carrying the 2026-07-28 _meta envelope opens a modern connection.

The era depends on the transport, not only on the request. An earlier version of this section said "over the same endpoint", and that was wrong in a way nothing caught: the modern single-exchange delivery lives behind StreamableHTTPSessionManager, which only the Streamable HTTP app reaches. The shipped transport was SSE, and SSE requires a session while a modern request is session-less by construction.

MCP_TRANSPORT

Endpoint

Handshake era

2026-07-28

stdio (default)

–

yes

yes

http

/mcp, plus /sse + /messages/ alongside

yes

yes

sse (legacy)

/sse + /messages/

yes

no

MCP_TRANSPORT=http serves both: the SSE routes run next to /mcp rather than being replaced, so an existing client does not break because the server gained a revision. Containers (Dockerfile, docker-compose.yml, render.yaml) ship http.

Both revisions are pinned in tests/test_protocol_version.py and asserted against the installed SDK, so a Dependabot bump of mcp cannot move either one silently. Since that gate can only read SDK constants, tests/test_spec_2026_07_28.py sits next to it and measures the wire instead: a real 2026-07-28 envelope against the assembled ASGI app, with the same envelope against SSE as the counter-control.

Note that the SDK's LATEST_PROTOCOL_VERSION is an alias for the modern era, not for the handshake era — pinning against it alone would leave the era that current clients actually negotiate free to drift.

Update policy. When the gate fails, do not edit the constant blindly: read the spec changelog between the two revisions, verify the server still behaves, then move the constant, this section, README.de.md and CHANGELOG.md together.


Testing

# All tests
pytest tests/ -v

# Quick check (without pytest)
python tests/test_phase3.py

Safety & Limits

  • Read-only: All tools perform HTTP GET requests only — no data is written, modified, or deleted on any upstream system.

  • No personal data: Location coordinates passed as tool inputs are not stored, logged, or forwarded beyond the immediate API request. API responses contain no PII — only vehicle counts, charger availability, traffic events, and geographic metadata.

  • Rate limiting: The server enforces client-side rate limits (Shared Mobility: 30 req/60s; EV Charging: 10 req/60s) to protect upstream APIs. The DATEX II key is subject to opentransportdata.swiss fair-use terms.

  • Caching: Responses are cached in-process (Sharing: 60s · EV: 5 min · Park+Rail: 5 min · Traffic: 1–2 min). Real-time data reflects the cache age, not necessarily the current second.

  • Terms of service: Data is subject to the ToS of each upstream source — sharedmobility.ch, ich-tanke-strom.ch, opentransportdata.swiss, data.sbb.ch (CC BY), geo.admin.ch (BGDI).

  • No guarantees: This server is an independent community project, not affiliated with SBB, ASTRA, sharedmobility.ch, or any API provider. Availability depends on upstream services.


Changelog

See CHANGELOG.md


Contributing

See CONTRIBUTING.md


Security

See SECURITY.md for the security posture and vulnerability reporting.


License

MIT License — see LICENSE


Author

Hayal Oezkan · malkreide


Installation

Run via uv's uvx — no clone or manual install needed. Add to your MCP client config (mcpServers for Claude Desktop, Cursor and Windsurf; use a top-level servers key for VS Code in .vscode/mcp.json):

{
  "mcpServers": {
    "swiss-road-mobility-mcp": {
      "command": "uvx",
      "args": [
        "swiss-road-mobility-mcp"
      ]
    }
  }
}

Available Tools

15 tools
road_charger_statusA
Read-only

Check real-time availability of EV charging stations.

Can check specific stations by ID, or get overall statistics for ALL charging points in Switzerland.

Use road_find_charger first to get station IDs, then use this tool to check their current status.

Returns: JSON with real-time status per station, or overall statistics (how many free/occupied/out of service).

Inputs: params (required). Returns: object

road_check_statusA
Read-onlyIdempotent

Check the health of all road mobility data sources.

Tests connectivity to sharedmobility.ch and ich-tanke-strom.ch. Useful for diagnosing connection issues.

Returns: JSON with status of each API endpoint.

Inputs: no named parameters. Returns: object

road_classify_roadA
Read-onlyIdempotent

Classify roads at a location using the official Swiss topographic road network (swissTLM3D).

The swissTLM3D is the authoritative federal road network dataset from swisstopo. It classifies every road in Switzerland by:

Road type (Objektart): 🛣️ Autobahn · 🚗 Hauptstrasse · 🏘️ Nebenstrasse · 🚶 Weg/Pfad …

Functional class (Verkehrsbedeutung): Hauptverbindungsstrasse · Verbindungsstrasse · Sammelstrasse · Zufahrtstrasse

Surface (Belagsart): Hartbelag (Asphalt/Beton) · Weich-/Naturbelag

Ownership (Eigentümer): Bund · Kanton · Gemeinde · Privat

Access restriction (Verkehrsbeschränkung): Keine Beschränkung · Einsatzkräfte · Landwirtschaft · Fussgänger und Radfahrer · Kein öffentlicher Verkehr …

Use cases:

  • «Is this a motorway or a local road?»

  • «Who maintains this road – canton or municipality?»

  • Enriching traffic counter data with official road classification

Phase 4 tool – no API key required! Data source: geo.admin.ch / swisstopo swissTLM3D Strassen.

Returns: JSON with road segments at the location, each containing: - road_name: Official road name (if assigned) - road_type: {code, label_de, label_en, emoji, network_importance} - surface, functional_class, ownership, access_restriction Plus a type_summary overview.

Inputs: params (required). Returns: object

road_counter_sitesA
Read-onlyIdempotent

List Swiss traffic counting stations near a location (without real-time data).

Returns the measurement site metadata (name, coordinates, supplier) without fetching the live measurement data. Use this to discover available stations before querying road_traffic_counters.

Site table is cached for 24 hours (rarely changes).

REQUIRES: OPENTRANSPORTDATA_API_KEY environment variable. Free registration: https://api-manager.opentransportdata.swiss

Returns: JSON with list of nearby counting stations: - id: DATEX II station identifier (use in road_traffic_counters) - name: Human-readable station name (German) - latitude / longitude: GPS coordinates - distance_km: Distance from your search location - supplier: Data provider (ASTRA, Kanton ZH, Kanton BE, etc.)

Inputs: params (required). Returns: object

road_find_chargerA
Read-only

Find EV charging stations near a location in Switzerland.

Searches ich-tanke-strom.ch data for nearby charging stations with real-time availability, plug types, and charging power.

Like the "nearest charger" feature in an electric car's navigation.

Data source: ich-tanke-strom.ch (Swiss Federal Office of Energy). No API key required – completely open data!

Returns: JSON with nearby charging stations sorted by distance, including real-time status (free/occupied), plug types, charging power (kW), and operator information.

Inputs: params (required). Returns: object

road_find_sharingA
Read-only

Find shared mobility vehicles and stations near a location in Switzerland.

Searches for bikes, e-bikes, e-scooters, cars, and other shared vehicles within a radius around GPS coordinates. Returns real-time availability data from sharedmobility.ch.

Like checking a mobility app: "What sharing options are near me?"

Data source: sharedmobility.ch (Swiss Federal Office of Energy). No API key required – completely open data!

Returns: JSON with nearby vehicles/stations, grouped by type, with availability status and booking app links. A result carrying completeness with complete: false is a partial answer — tell the user which vehicle types it lacks instead of presenting it as the full picture.

Inputs: params (required). Returns: object

road_geocode_addressA
Read-onlyIdempotent

Convert a Swiss address to GPS coordinates using the official federal address registry.

Uses swisstopo's amtliches Gebäudeadressverzeichnis (GWR-based) – the authoritative Swiss federal building address register containing every officially registered address in Switzerland.

Unlike general geocoders, this returns only verified, legally registered addresses. Every result has an EGAID (Eidgenössischer Adressidentifikator) and EGID (Gebäudeidentifikator) from the federal GWR register.

Think of it as the «official digital postman»: if the address exists in Switzerland, it's here. If it's not here, it may not be officially registered.

Phase 4 tool – no API key required! Data source: geo.admin.ch / swisstopo amtliches Gebäudeadressverzeichnis.

Returns: JSON with matching addresses, each containing: - address: Full address string (e.g. «Bahnhofstrasse 1 8001 Zürich») - latitude / longitude: WGS84 coordinates - feature_id: ID in the federal address register - source: Layer ID (ch.swisstopo.amtliches-gebaeudeadressverzeichnis)

Inputs: params (required). Returns: object

road_mobility_snapshotA
Read-only

Get a complete mobility picture for any Swiss location in one call.

Aggregates in parallel:

  • Shared vehicles nearby (bikes, e-scooters, cars)

  • EV charging stations

  • Park & Rail facilities at nearby train stations

  • Nearest train station (transport.opendata.ch)

  • Traffic situations if Phase 2 API key is configured (optional)

This is the «mobility cockpit» – the control tower view. Instead of calling 5 different tools, get everything at once.

Phase 3 cross-server tool: No extra API key needed beyond what Phase 2 already requires (and Phase 2 data is optional).

Perfect for demos: «Show me everything mobility-related at [location].»

Data sources:

  • sharedmobility.ch (no key)

  • ich-tanke-strom.ch (no key)

  • SBB Open Data / data.sbb.ch (no key)

  • transport.opendata.ch (no key)

  • opentransportdata.swiss DATEX II (optional, Phase 2 key)

Returns: JSON with nearest_station, shared_mobility, ev_charging, park_rail, and optional traffic_situations – all for one location.

Inputs: params (required). Returns: object

road_multimodal_planA
Read-only

Plan a multimodal trip: Drive → Park & Rail → Train → Destination.

The «Holy Grail» of Phase 3: combines all data sources into a complete door-to-door multimodal route plan.

Workflow (all in parallel where possible):

  1. Find the nearest train station from your start location

  2. Find Park & Rail facilities near the start (where to park your car)

  3. Get public transport connections from nearest station to destination

  4. Check shared mobility options at start for last-mile to station

  5. Assemble everything into a step-by-step route plan

Use case: «I'm in Dietikon with a car. I need to get to Bern. Where can I park? Which train should I take?»

No API key required – uses:

  • SBB Open Data (Park & Rail) – free

  • transport.opendata.ch (PT connections) – free

  • sharedmobility.ch (sharing options) – free

Data sources:

  • SBB Open Data Portal (data.sbb.ch) – Park & Rail

  • transport.opendata.ch – Journey planning

  • sharedmobility.ch – Sharing last mile

Returns: JSON with: - nearest_station: Closest train station from start - recommended_park_rail: Best P+R option - plan_steps: Step-by-step multimodal route - all_ov_connections: All available PT connections - last_mile_sharing: Sharing options at start location

Inputs: params (required). Returns: object

road_park_railA
Read-only

Find Park & Rail parking facilities near Swiss train stations.

Returns SBB-operated Park & Rail lots with capacity and location.

Phase 3 tool – the link between road and rail: «Park here, then take the train.»

No API key required – completely open data!

Data source: Open-Data-Plattform Mobilität Schweiz (opentransportdata.swiss, Park+Rail GeoJSON). Cache TTL: 5 minutes.

Returns: JSON with nearby Park & Rail facilities sorted by distance, including total spaces and capacity by category.

Inputs: params (required). Returns: object

road_reverse_geocodeA
Read-onlyIdempotent

Find the nearest official Swiss addresses for given GPS coordinates.

Uses the federal building address register (amtliches Gebäudeadressverzeichnis) to identify the nearest registered building addresses to any point in Switzerland.

Returns official GWR (Gebäude- und Wohnungsregister) data including:

  • EGID (Eidgenössischer Gebäudeidentifikator) – unique federal building ID

  • EGAID (Eidgenössischer Adressidentifikator) – unique federal address ID

  • Building category (residential / non-residential)

  • Official address status

Especially useful for enriching mobility data: finding the exact legal address of a charging station, Park & Rail facility, or sharing station.

Phase 4 tool – no API key required! Data source: geo.admin.ch / swisstopo amtliches Gebäudeadressverzeichnis (GWR).

Returns: JSON with nearest official addresses including EGID/EGAID identifiers, municipality data, and building category.

Inputs: params (required). Returns: object

road_search_sharingA
Read-onlyIdempotent

Search for shared mobility stations by name or address.

Full-text search across all Swiss shared mobility stations. Useful when you know the station name but not the coordinates.

Example: "Find all PubliBike stations near 'Bahnhof'"

Returns: JSON with matching stations, their locations, and availability.

Inputs: params (required). Returns: object

road_sharing_providersA
Read-onlyIdempotent

List all shared mobility providers operating in Switzerland.

Shows which companies offer shared bikes, e-scooters, cars etc., what vehicle types they have, and links to their booking apps.

Like checking the "About" page of a mobility platform.

Returns: JSON with all providers, their vehicle types, and app links.

Inputs: no named parameters. Returns: object

road_traffic_countersA
Read-only

Get real-time vehicle counts and speeds at Swiss traffic measurement stations.

Finds nearby counting stations and returns live traffic flow data: vehicles per hour (separated by light/heavy vehicles) and average speeds.

Data is updated every minute by ASTRA and cantonal road authorities. This is the «digital tally counter» of Swiss roads – precise, live, distinguishing passenger cars from trucks.

Use case: «How busy is the A1 near Zurich right now?» or «How much truck traffic passes through Lucerne hourly?»

REQUIRES: OPENTRANSPORTDATA_API_KEY environment variable. Free registration: https://api-manager.opentransportdata.swiss

Data source: ASTRA & cantonal authorities via opentransportdata.swiss (DATEX II). Cache TTL: Site table 24h (static) + measurements 1 minute (real-time).

Returns: JSON with nearby counting stations and their current measurements: - site_id: Unique station identifier - name: Station name - distance_km: Distance from search center - latitude / longitude: Station coordinates - supplier: Data provider (ASTRA, Kanton ZH, etc.) - measurement_time: Timestamp of latest measurement - flow_light_vehicles_per_hour: Cars, motorcycles, buses - flow_heavy_vehicles_per_hour: Trucks, articulated lorries - flow_total_per_hour: Combined flow - avg_speed_light_kmh: Average speed of light vehicles - avg_speed_heavy_kmh: Average speed of heavy vehicles

Inputs: params (required). Returns: object

road_traffic_situationsA
Read-only

Get current Swiss traffic events: accidents, roadworks, congestion.

Fetches real-time traffic messages from ASTRA's DATEX II platform. Data is updated live by Swiss Traffic Management Center (VMZ-CH), cantonal police, and road operation units.

Complements Phase 1: While road_find_sharing shows WHERE vehicles are available, this tool shows WHY a road is currently blocked.

REQUIRES: OPENTRANSPORTDATA_API_KEY environment variable. Free registration: https://api-manager.opentransportdata.swiss

Data source: ASTRA VMZ-CH via opentransportdata.swiss (DATEX II v2.3). Cache TTL: 2 minutes (real-time updates).

Returns: JSON with list of traffic situations, each containing: - id: Situation identifier - records: List of situation records with: - category: Event type (accident/roadwork/congestion/etc.) - validity_status: active/revoked - start_time / end_time: Validity period - severity: highest/high/medium/low/lowest - description: Human-readable text (German preferred) - creation_time: When situation was created

Inputs: params (required). Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 15 tools

    Disambiguation4/5

    Most tools target clearly distinct data domains (park & rail, sharing, charging, traffic, geocoding, road classification). Minor overlap exists between road_find_sharing (proximity) and road_search_sharing (full-text), and between road_traffic_counters (live data) and road_counter_sites (metadata), but descriptions explicitly clarify each role. The aggregate tools road_mobility_snapshot and road_multimodal_plan are distinguished as snapshot vs. route planner.

    Naming Consistency4/5

    All 15 tools use snake_case with a uniform 'road_' prefix, giving a strong predictable family. The internal pattern is slightly mixed, however: some are verb_noun (road_find_sharing, road_geocode_address) while others are noun_noun (road_traffic_situations, road_counter_sites, road_mobility_snapshot), but readability remains high.

    Tool Count5/5

    15 tools is well within the ideal range and each earns its place across distinct sub-domains (park & rail, sharing, charging, traffic, geocoding, road classification, aggregation). No redundant filler tools are present, and the count matches the breadth of a national mobility data server.

    Completeness4/5

    The surface covers discovery, live status, geocoding (forward/reverse), road classification, aggregation, and multimodal planning, giving broad lifecycle coverage for a data-serving server. Minor gaps: no charger detail-by-ID beyond status counts, and no explicit booking/link tool, but agents can work around these.

    Maintenance

    ActivityActive
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers