convez.ai
MCP ServerIntegração & APIsIntermediário
malkreide

Swiss Transport MCP

malkreide/swiss-transport-mcp

Sistema completo de informações de transporte suíço para assistentes de IA

Ver no GitHub
BomPluginScore · de 0 a 100

Servidor MCP que conecta modelos de IA ao sistema de transporte público suíço, oferecendo planejamento de jornadas, informações de partidas em tempo real, alertas de perturbações, previsões de ocupação, preços de bilhetes e composição de trens. Integra múltiplas APIs do opentransportdata.swiss traduzindo-as em JSON limpo para o modelo.

Instalação

$npx convez-ai malkreide/swiss-transport-mcp

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
7
Forks
3
Acompanhando
0
Saúde
71%
Último commit
há 2 semanas
Versão
v0.5.0
Issues abertas
3
Contribuidores
2

Casos de uso

  • Planejar jornadas de transporte com transferências e verificar perturbações em tempo real
  • Consultar partidas, atrasos e informações de plataforma para estações suíças
  • Verificar previsões de ocupação, preços de bilhetes e composição de trens para decisões de viagem
  • Integrar dados de transporte abertos em aplicações inteligentes

Veredito

MCP server bem estruturado e completo que democratiza acesso a dados suíços de transporte para LLMs. Implementação madura com suporte a múltiplos protocolos (OJP, SIRI-SX) e degradação graciosa sem chaves API opcionais.

README

A tradução para o português deste README ainda está na fila.

🇨🇭 Part of the Swiss Public Data MCP Portfolio

🚆 swiss-transport-mcp

Version License: MIT Python 3.11+ MCP Data Source CI

MCP server connecting AI models to the Swiss public transport system – journey planning, real-time departures, disruptions, occupancy, ticket prices, train formations and open data from opentransportdata.swiss.

🇩🇪 Deutsche Version

Demo

Demo: Claude queries disruptions and departures


Overview

swiss-transport-mcp gives AI assistants like Claude a complete Swiss travel information system – not just timetables, but also real-time disruption alerts, occupancy forecasts, ticket prices, and a full train formation view. All accessible through a single, standardised MCP interface.

The various APIs at opentransportdata.swiss speak different protocols – OJP 2.0 (XML/SOAP), SIRI-SX (XML), REST/JSON. This server translates everything into clean JSON for the AI model, acting as a multilingual protocol interpreter.

Anchor demo query: "Plan a school trip for 25 students from Zurich to the Technorama in Winterthur – check for disruptions and find the best departure." → More use cases by audience →


Features

  • 🗺️ Journey planning (A → B with transfers, duration, transport mode) via OJP 2.0
  • 🕐 Real-time departures with delays and platform information
  • 🔍 Stop search by name or coordinates
  • 🚨 Live disruption alerts (cancellations, closures) via SIRI-SX
  • 📊 Occupancy forecasts for trains (SBB, BLS, Thurbo, SOB)
  • 💰 Ticket prices including class selection
  • 🚃 Train formation – coaches, classes, amenities, accessibility
  • 📦 Open data catalogue – ~90 transport datasets via CKAN
  • 🔑 Graceful degradation – server starts with core tools even without optional API keys
  • ☁️ Dual transport – stdio for Claude Desktop, Streamable HTTP/SSE for cloud deployment

Prerequisites


Installation

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

# Install
pip install -e .

Or with uvx (no permanent installation):

uvx swiss-transport-mcp

Quickstart

# Set the minimum required key (OJP core tools)
export TRANSPORT_API_KEY=your_key_here

# Start the server (stdio mode for Claude Desktop)
swiss-transport-mcp

Try it immediately in Claude Desktop:

"What are the next departures from Zurich Stadelhofen?" "How do I get from Wädenswil to Bern by train?"


Configuration

Environment Variables

VariableAPIRequired
TRANSPORT_API_KEYUnified key for OJP + CKAN✅ (or individual keys)
TRANSPORT_OJP_API_KEYOJP 2.0 Journey PlannerOptional (override)
TRANSPORT_CKAN_API_KEYCKAN data catalogueOptional (separate subscription)
SIRI_SX_API_KEYDisruption alerts (SIRI-SX)Optional
OCCUPANCY_API_KEYOccupancy forecastOptional
FORMATION_API_KEYTrain formationOptional
OJP_FARE_API_KEYTicket prices (OJP Fare)Optional

APIs without a key are silently disabled – the server starts fine with just the 6 core tools.

Operational / security variables:

VariableEffectDefault
MCP_ENV / ENVProcess environment. Must be dev/development/local/test to allow disabling TLS verification.(unset → production)
TRANSPORT_SSL_VERIFYSet to false to disable TLS certificate verification. Honoured only when MCP_ENV marks a dev environment – otherwise the request is ignored and verification stays on.true
TRANSPORT_CKAN_URLOverride the CKAN base URL. Must stay on the egress allow-list (*.opentransportdata.swiss); off-site overrides are refused.https://api.opentransportdata.swiss/ckan-api
MCP_CORS_ORIGINSComma-separated list of browser origins allowed to call the HTTP transport. Use * to allow any origin (not recommended). The Mcp-Session-Id header is exposed to these origins.https://claude.ai
LOG_FORMATjson for structured logs (RFC 5424 severity); anything else for human-readable text. Always written to stderr.text
OTEL_TRACES_ENABLED1 to enable OpenTelemetry tracing (requires the otel extra: pip install 'swiss-transport-mcp[otel]'). No-op otherwise.(off)
MCP_STATELESS1 to run the Streamable HTTP transport statelessly — no server-side session state, so instances need no sticky load balancing. Recommended for horizontal scale-out.(off → stateful)

🔒 Egress allow-list: all outbound requests are restricted to https:// on opentransportdata.swiss hosts. Any other host is refused before a request is sent (SSRF / egress hardening).

Claude Desktop Configuration

Minimal (core tools only):

{
  "mcpServers": {
    "swiss-transport": {
      "command": "swiss-transport-mcp",
      "env": {
        "TRANSPORT_API_KEY": "your_key_here"
      }
    }
  }
}

Full (all 11 tools):

{
  "mcpServers": {
    "swiss-transport": {
      "command": "swiss-transport-mcp",
      "env": {
        "TRANSPORT_API_KEY": "your_ojp_key_here",
        "SIRI_SX_API_KEY": "your_siri_key_here",
        "OCCUPANCY_API_KEY": "your_occupancy_key_here",
        "FORMATION_API_KEY": "your_formation_key_here",
        "OJP_FARE_API_KEY": "your_fare_key_here"
      }
    }
  }
}

Config file locations:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json

Cloud Deployment (Streamable HTTP)

For use via claude.ai in the browser (e.g. on managed workstations without local software). The cloud transport is Streamable HTTP (MCP_TRANSPORT=streamable-http, endpoint /mcp). SSE (/sse) is still supported but deprecated.

MCP_TRANSPORTUseEndpoint
stdio (default)Local Claude Desktop subprocess–
streamable-http (or http)Cloud / container (recommended)/mcp
sseLegacy browser transport (deprecated)/sse

Docker (recommended):

# Build + run with explicit resource limits (see docker-compose.yml)
TRANSPORT_API_KEY=xxx docker compose up --build
# → http://127.0.0.1:8000/mcp

The image is a multi-stage build running as a non-root user; docker-compose.yml adds read_only, no-new-privileges and memory/CPU/PID limits.

Render.com:

  1. Push/fork the repository to GitHub
  2. On render.com: New Web Service → connect GitHub repo (Docker runtime)
  3. Set env MCP_TRANSPORT=streamable-http and MCP_HOST=0.0.0.0
  4. In claude.ai under Settings → MCP Servers, add: https://your-app.onrender.com/mcp

💡 "stdio for the developer laptop, Streamable HTTP for the cloud."

Scaling horizontally: run with MCP_STATELESS=1. In stateless mode the server keeps no per-session state, so any instance can serve any request and a plain round-robin load balancer suffices — no sticky sessions / Mcp-Session-Id affinity required. If you need stateful streaming instead, route by Mcp-Session-Id at the edge LB (e.g. HAProxy stick-tables) so each session stays pinned to one instance.

⚠️ Binding: In a network transport the server binds to 127.0.0.1 by default so a locally started server is not exposed to your whole network (e.g. public Wi-Fi). Set MCP_HOST=0.0.0.0 only in a container/cloud environment where binding to all interfaces is intended (the Docker image does this for you).


Available Tools

Core Tools (OJP 2.0 / CKAN)

ToolDescriptionData Source
transport_search_stopSearch stops/stations by nameOJP 2.0
transport_nearby_stopsFind nearby stops by coordinatesOJP 2.0
transport_departuresReal-time departure board with delays & platformsOJP 2.0
transport_trip_planPlan journey A → B with transfers, duration, modeOJP 2.0
transport_search_datasetsSearch open data catalogue (~90 datasets)CKAN¹
transport_get_datasetGet full details of a specific datasetCKAN¹

¹ CKAN tools require a separate subscription in the API Manager.

Extension Tools (optional API keys)

ToolDescriptionData Source
get_transport_disruptions🚨 Live disruptions, cancellations, line closuresSIRI-SX
get_train_occupancy📊 Occupancy forecast for specific trainsOccupancy JSON
get_ticket_price💰 Ticket prices for connectionsOJP Fare
get_train_composition🚃 Train formation, classes, accessibilityFormation REST
check_transport_api_status🔍 Health check for all configured APIsAll

Example Use Cases

QueryTool
"Next trains from Zurich Stadelhofen?"transport_departures
"Plan a trip for 25 students from Zurich to Winterthur Technorama"transport_trip_plan
"Any disruptions between Zurich and Bern?"get_transport_disruptions
"How full is IC 1009 today?"get_train_occupancy
"What does a ticket from Wädenswil to Bern cost?"get_ticket_price
"Does IC 708 have a dining car?"get_train_composition
"Which stops are near Langstrasse 100?"transport_nearby_stops

Architecture

┌─────────────────┐     ┌───────────────────────────┐     ┌──────────────────────────┐
│   Claude / AI   │────▶│   Swiss Transport MCP     │────▶│  opentransportdata.swiss  │
│   (MCP Host)    │◀────│   (MCP Server)            │◀────│                          │
└─────────────────┘     │                           │     │  OJP 2.0  (XML/SOAP)     │
                        │  11 Tools · 2 Resources   │     │  SIRI-SX  (XML)          │
                        │  Stdio | SSE              │     │  CKAN     (REST/JSON)    │
                        │                           │     │  Occupancy(REST/JSON)    │
                        │  Core:                    │     │  Formation(REST/JSON)    │
                        │   api_client + ojp_client │     │  OJP Fare (XML/SOAP)     │
                        │  Extensions:              │     └──────────────────────────┘
                        │   siri_sx, occupancy,     │
                        │   ojp_fare, formation     │
                        └───────────────────────────┘

Infrastructure Components

ComponentMetaphorFunction
RateLimiterBouncerLimits API calls per time window
SimpleCacheWhiteboardCaches responses for repeated queries
APIClientSwitchboardHandles auth, redirects, errors centrally
APIConfigBusiness cardKey, URL, limits per API

Caching Strategy

APICache TTLRationale
SIRI-SX120sDisruptions don't change every second
Occupancy300sForecasts are day-based
Formation600sTrain composition is stable for the day
OJP Fare1800sPrices rarely change intraday

Project Structure

swiss-transport-mcp/
├── src/swiss_transport_mcp/        # Main package
│   ├── server.py                   # FastMCP server, tool definitions
│   ├── api_client.py               # Core OJP + CKAN client
│   ├── ojp_client.py               # OJP 2.0 XML/SOAP parser
│   ├── api_infrastructure.py       # RateLimiter, SimpleCache, APIClient
│   ├── siri_sx.py                  # Disruption alerts
│   ├── occupancy.py                # Occupancy forecasts
│   ├── ojp_fare.py                 # Ticket prices
│   └── formation.py                # Train formation
├── tests/
│   └── test_server.py              # Unit + integration tests
├── .github/workflows/ci.yml        # GitHub Actions (Python 3.11/3.12/3.13)
├── claude_desktop_config.json       # Example Claude Desktop config
├── pyproject.toml
├── CHANGELOG.md
├── CONTRIBUTING.md
├── LICENSE
├── README.md                        # This file (English)
└── README.de.md                     # German version

Safety & Limits

  • Read-only: All tools perform read-only requests (HTTP GET / OJP XML POST for queries only) — no data is written, modified, or deleted on any upstream system.
  • No personal data: Journey queries are transient and not stored by this server. The APIs return scheduled timetable and real-time operational data. No personally identifiable information (PII) is processed or retained.
  • Rate limits: opentransportdata.swiss enforces per-key rate limits (documented in the API Manager). The server's built-in RateLimiter (SIRI-SX: 2 req/min, Formation/OJP Fare: 5 req/min) stays within these bounds automatically. Use the limit parameters conservatively for bulk queries.
  • API key required: A free key from api-manager.opentransportdata.swiss is mandatory. Keys are bound to your account's subscription — only subscribe to APIs you intend to use.
  • Data freshness: Real-time tools (departures, disruptions, occupancy) reflect the upstream source at query time. The server caches responses for short TTLs (120s–1800s) to reduce API load — see the Caching Strategy table above.
  • Terms of service: Data is subject to the ToS of opentransportdata.swiss. OJP, SIRI-SX, and the CKAN catalogue are published under open licences (ODbL / CC BY 4.0) for non-commercial and research use.
  • No guarantees: This server is a community project, not affiliated with the Federal Office of Transport (BAV/OFT) or SBB. Availability depends on upstream APIs.

Before you install (consent)

Adding this server to your MCP client lets the connected AI model issue Swiss public-transport queries on your behalf, using your opentransportdata.swiss API key, and make outbound HTTPS requests to opentransportdata.swiss. Nothing is written upstream and no PII is stored, but you should review the tool list above and confirm you are comfortable granting that access before configuring the server.

Running the HTTP transport safely (no built-in auth)

The server has no authentication of its own. When you run the Streamable HTTP transport (MCP_TRANSPORT=streamable-http), the MCP SDK issues a cryptographically random Mcp-Session-Id per session, but there is no user identity bound to it. Therefore:

  • Do not expose a no-auth instance directly to the public internet. Put it behind an authenticating reverse proxy (OAuth2 proxy, mTLS, or your platform's access control), or restrict it to a trusted network.
  • Keep the default MCP_HOST=127.0.0.1 for local use; only bind 0.0.0.0 inside a controlled container/cloud environment (see Deployment).
  • Scope MCP_CORS_ORIGINS to the origins you actually trust.

See SECURITY.md for the full security posture and the accepted-risk decisions (gateway-level controls).


Known Limitations

  • OJP Fare: Discounts (Halbtax, GA, regional passes) are not always reflected
  • Formation: Stop-based data is only available for TODAY (real-time dependency)
  • Occupancy: SBB, BLS, Thurbo and SOB only – no private railways
  • SIRI-SX: Returns ALL Swiss disruptions → use the filter_text parameter
  • CKAN: Requires a separate subscription in the API Manager

Testing

# Unit tests (no API key required)
PYTHONPATH=src pytest tests/ -m "not live"

# Integration tests (API key required)
TRANSPORT_API_KEY=xxx pytest tests/ -m "live"

Changelog

See CHANGELOG.md


Contributing

See CONTRIBUTING.md


License

MIT License — see LICENSE


Author

Hayal Oezkan · github.com/malkreide


Credits & Related Projects

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-transport-mcp": {
      "command": "uvx",
      "args": [
        "swiss-transport-mcp"
      ]
    }
  }
}
Ver o original no GitHub

Bom para

Relacionados