swiss-road-mobility-mcp
Swiss road & mobility data via MCP — 15 read-only tools covering shared vehicles, EV charging, live traffic, Park & Rail, multimodal trip planning, and official geocoding/road classification.
Shared mobility — find nearby bikes, e-bikes, e-scooters, cars by GPS/radius (
road_find_sharing), search stations by name (road_search_sharing), list all CH providers (road_sharing_providers).EV charging — locate chargers near a point with power/plug/operator details (
road_find_charger) and check real-time free/occupied status of specific stations or all of Switzerland (road_charger_status).Traffic (free API key) — live accidents, roadworks and congestion from ASTRA/VMZ-CH (
road_traffic_situations), real-time vehicle counts and speeds at counting stations (road_traffic_counters), and station metadata lookup (road_counter_sites).Park & Rail — find SBB P+R facilities near stations with capacity data (
road_park_rail).Aggregated view — one call gives the complete mobility picture for any location: sharing, EV, Park & Rail, nearest station, optional traffic (
road_mobility_snapshot).Multimodal trip planning — plan door-to-door car → Park & Rail → train → destination routes with last-mile sharing options (
road_multimodal_plan).Geocoding & addresses — official federal address lookup (
road_geocode_address), reverse geocoding with EGID/EGAID building IDs (road_reverse_geocode).Road classification — classify roads by type, surface, ownership and access restrictions using swissTLM3D (
road_classify_road).Health check — verify connectivity to upstream data sources (
road_check_status).No API key needed for 12 of 15 tools; only DATEX II traffic tools require a free opentransportdata.swiss key. All tools are read-only HTTP GETs with caching and rate limiting.
Enables OpenTelemetry tracing for all upstream API calls (via httpx instrumentation) and SSE requests, with spans exported to an OTLP collector. Can be enabled by setting MCP_TRACING_ENABLED=true or by configuring OTEL_EXPORTER_OTLP_ENDPOINT, and honors standard OTEL_* environment variables.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@swiss-road-mobility-mcp Plan a multimodal trip from Dietikon to Bern"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
🇨🇭 Part of the Swiss Public Data MCP Portfolio
🚗 Swiss Road & Mobility MCP Server
MCP Server for Swiss road mobility — shared vehicles, EV charging, traffic alerts, Park & Rail, and multimodal trip planning
Demo
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 locationroad_multimodal_plan— car + Park & Rail + public transport in one planNo 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-mcpQuickstart
# 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-mcpTry 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.jsonWindows:
%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):
Push/fork the repository to GitHub
On render.com: New Web Service -> connect GitHub repo
Set start command:
MCP_TRANSPORT=http MCP_PORT=8001 swiss-road-mobility-mcpIn claude.ai under Settings -> MCP Servers, add
https://your-app.onrender.com/mcp— or.../ssefor a client that still speaks the SSE transport;httpserves 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 |
| When set, every SSE request must send |
| Max requests per client IP per window (default |
| Window length in seconds (default |
| Comma-separated CORS origins for browser clients. Empty by default: no cross-origin access. |
The local stdio transport needs none of this — it runs in the user's trusted context.
Observability (OBS-003 / OBS-006)
Variable | Effect |
| Log level: |
|
|
|
|
| OTLP collector URL; setting it also enables tracing. Standard |
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 |
| Shared mobility nearby (bikes, e-scooters, cars) | 60s |
| Search sharing stations by name | 5min |
| All sharing providers in Switzerland | 1h |
| EV charging stations nearby | 5min |
| Real-time availability of charging stations | 1min |
| Server & API health check | - |
Traffic (free API key required)
Tool | Description | Cache |
| Accidents, roadworks, congestion from ASTRA/VMZ-CH | 2min |
| Vehicles/h + km/h at counting stations near a position | 1min |
| List counting stations nearby | 24h |
Park & Rail + Multimodal (no API key required)
Tool | Description | Cache |
| Find SBB Park+Rail facilities nearby | 5min |
| Complete mobility overview for a location | - |
| Plan car -> Park+Rail -> public transport -> destination | - |
Geography & Addresses — Phase 4 (no API key required)
Tool | Description | Cache |
| Swiss address -> GPS (official building address register) | - |
| GPS -> official address with EGID/EGAID (GWR) | - |
| Road classification via swissTLM3D | - |
Example Use Cases
Query | Tool |
"Find shared bikes near Zurich HB" |
|
"Where can I charge my EV near Bern?" |
|
"Any traffic incidents on the A1?" |
|
"Where can I park near Winterthur station?" |
|
"Plan my trip from Dietikon to Bern by car + train" |
|
API Key for Traffic Tools
Create a new application -> subscribe to the "Strassenverkehr" API
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 classificationData 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 versionKnown Limitations
Shared Mobility: The
sharedmobility.chAPI does not enforce strict radius filtering; vehicles slightly outside the specified radius may appearEV 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 |
|
| What today's clients speak. The server answers with the revision asked for, or with the |
Per-request envelope |
| A request carrying the |
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.
| Endpoint | Handshake era |
|
| – | yes | yes |
|
| yes | yes |
|
| 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.pySafety & 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
Credits & Related Projects
sharedmobility.ch: sharedmobility.ch — Swiss shared mobility platform
ich-tanke-strom.ch: ich-tanke-strom.ch — Swiss EV charging network
ASTRA / opentransportdata.swiss: opentransportdata.swiss — Federal traffic data
SBB Open Data: data.sbb.ch — Swiss Federal Railways
geo.admin.ch: geo.admin.ch — Federal geospatial services
Protocol: Model Context Protocol — Anthropic / Linux Foundation
Related: swiss-transport-mcp — Public transport (trains, buses, trams)
Related: zurich-opendata-mcp — 900+ datasets from the City of Zurich
Portfolio: Swiss Public Data MCP Portfolio
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 toolsroad_charger_statusARead-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_statusARead-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_roadARead-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_sitesARead-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_chargerARead-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_sharingARead-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_addressARead-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_snapshotARead-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_planARead-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):
Find the nearest train station from your start location
Find Park & Rail facilities near the start (where to park your car)
Get public transport connections from nearest station to destination
Check shared mobility options at start for last-mile to station
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_railARead-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_geocodeARead-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_sharingARead-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_providersARead-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_countersARead-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_situationsARead-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
Scored across 15 tools
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.
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.
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.
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
Related MCP Connectors
MCP server for Travel & Transportation
MCP Server for an Agent Task Marketplace
One MCP server for the services your AI needs: memory, files, Microsoft 365, kanban and more.
MCP server for Boson Protocol — on-chain agentic commerce for physical & digital goods.
Related MCP Servers
- AlicenseBqualityBmaintenanceSwiss open data MCP server — transport, weather, geodata, companies, etc,. Zero API keys.94416 npm27MIT
- AlicenseAqualityDmaintenanceA zero-authentication MCP server for Swiss public transport, enabling users to query train connections, disruptions, station facilities, and plan journeys using natural language.121MIT
- AlicenseAqualityBmaintenanceMCP server for Swiss federal geodata -- maps, elevation, geocoding, cadastral extracts, and downloadable datasets via Swisstopo APIs.2062 PyPI12MIT
- AlicenseAqualityDmaintenanceMCP server for Swiss public transport — connections, stationboards, real-time delays, and direct booking links for SBB.440 PyPI1MIT