mcp-swiss 0.1.0

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "mcp-swiss",
+  "version": "0.1.0",
+  "description": "Swiss open data MCP server — transport, weather, geodata, companies. Zero API keys.",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-swiss": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run tests/unit tests/mcp",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:unit": "vitest run tests/unit",
+    "test:integration": "vitest run tests/integration",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "validate": "npm run lint && npm run build && npm test"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "switzerland",
+    "swiss",
+    "sbb",
+    "transport",
+    "weather",
+    "meteoswiss",
+    "swisstopo",
+    "zefix",
+    "opendata",
+    "ai",
+    "claude",
+    "cursor"
+  ],
+  "author": "Vikram Gorla",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vikramgorla/mcp-swiss.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vikramgorla/mcp-swiss/issues"
+  },
+  "homepage": "https://github.com/vikramgorla/mcp-swiss#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^10.0.3",
+    "typescript": "^5.3.0",
+    "typescript-eslint": "^8.56.1",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+import { transportTools, handleTransport } from "./modules/transport.js";
+import { weatherTools, handleWeather } from "./modules/weather.js";
+import { geodataTools, handleGeodata } from "./modules/geodata.js";
+import { companiesTools, handleCompanies } from "./modules/companies.js";
+
+const server = new Server(
+  { name: "mcp-swiss", version: "0.1.0" },
+  { capabilities: { tools: {} } }
+);
+
+const allTools = [
+  ...transportTools,
+  ...weatherTools,
+  ...geodataTools,
+  ...companiesTools,
+];
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: allTools,
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const safeArgs = (args ?? {}) as Record<string, unknown>;
+
+  try {
+    let result: string;
+
+    if (transportTools.some((t) => t.name === name)) {
+      result = await handleTransport(name, safeArgs);
+    } else if (weatherTools.some((t) => t.name === name)) {
+      result = await handleWeather(name, safeArgs);
+    } else if (geodataTools.some((t) => t.name === name)) {
+      result = await handleGeodata(name, safeArgs);
+    } else if (companiesTools.some((t) => t.name === name)) {
+      result = await handleCompanies(name, safeArgs);
+    } else {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+
+    return {
+      content: [{ type: "text", text: result }],
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Error: ${message}` }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write("mcp-swiss running on stdio\n");
+}
+
+main().catch((err) => {
+  process.stderr.write(`Fatal: ${err}\n`);
+  process.exit(1);
+});

package/src/modules/companies.ts

@@ -0,0 +1,154 @@
+import { fetchJSON } from "../utils/http.js";
+
+const BASE = "https://www.zefix.admin.ch/ZefixREST/api/v1";
+
+export const companiesTools = [
+  {
+    name: "search_companies",
+    description: "Search Swiss company registry (ZEFIX) by name, canton, or legal form",
+    inputSchema: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: { type: "string", description: "Company name or partial name to search" },
+        canton: { type: "string", description: "Canton abbreviation (e.g. ZH, BE, GE, ZG)" },
+        legal_form: { type: "string", description: "Legal form code (e.g. 0106=GmbH, 0101=AG)" },
+        limit: { type: "number", description: "Max results (default: 20)" },
+      },
+    },
+  },
+  {
+    name: "get_company",
+    description: "Get full details of a Swiss company by its ZEFIX internal ID (ehraid). Use search_companies first to find the ehraid — it is returned in company search results.",
+    inputSchema: {
+      type: "object",
+      required: ["ehraid"],
+      properties: {
+        ehraid: { type: "number", description: "Company internal ZEFIX ID (ehraid integer, e.g. 119283). Returned by search_companies." },
+      },
+    },
+  },
+  {
+    name: "search_companies_by_address",
+    description: "Search Swiss companies registered at a specific address or locality",
+    inputSchema: {
+      type: "object",
+      required: ["address"],
+      properties: {
+        address: { type: "string", description: "Address or locality name" },
+        limit: { type: "number", description: "Max results (default: 20)" },
+      },
+    },
+  },
+  {
+    name: "list_cantons",
+    description: "List all Swiss cantons with their codes",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+  },
+  {
+    name: "list_legal_forms",
+    description: "List all Swiss company legal forms (AG, GmbH, etc.)",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+  },
+];
+
+export async function handleCompanies(name: string, args: Record<string, unknown>): Promise<string> {
+  switch (name) {
+    case "search_companies": {
+      const body: Record<string, unknown> = {
+        name: args.name as string,
+        maxEntries: (args.limit as number) ?? 20,
+        languageKey: "en",
+      };
+      if (args.canton) body.cantonAbbreviation = [args.canton as string];
+      if (args.legal_form) body.legalFormCode = args.legal_form as string;
+
+      const response = await fetch(`${BASE}/firm/search.json`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Accept": "application/json" },
+        body: JSON.stringify(body),
+      });
+      if (response.status === 404) {
+        return JSON.stringify({ companies: [], hasMoreResults: false }, null, 2);
+      }
+      if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      const data = await response.json() as { list?: unknown[]; hasMoreResults?: boolean; error?: unknown };
+      if (data.error) return JSON.stringify({ companies: [], hasMoreResults: false }, null, 2);
+      return JSON.stringify({ companies: data.list ?? [], hasMoreResults: data.hasMoreResults ?? false }, null, 2);
+    }
+
+    case "get_company": {
+      // ZEFIX firm/{id}.json uses the internal ehraid integer (not CHE uid)
+      const ehraid = args.ehraid as number;
+      const url = `${BASE}/firm/${ehraid}.json`;
+      const data = await fetchJSON<unknown>(url);
+      return JSON.stringify(data, null, 2);
+    }
+
+    case "search_companies_by_address": {
+      const body = {
+        name: args.address as string,
+        maxEntries: (args.limit as number) ?? 20,
+        languageKey: "en",
+      };
+      const response = await fetch(`${BASE}/firm/search.json`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Accept": "application/json" },
+        body: JSON.stringify(body),
+      });
+      if (response.status === 404) return JSON.stringify({ companies: [], hasMoreResults: false }, null, 2);
+      if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      const data = await response.json() as { list?: unknown[]; hasMoreResults?: boolean; error?: unknown };
+      if (data.error) return JSON.stringify({ companies: [], hasMoreResults: false }, null, 2);
+      return JSON.stringify({ companies: data.list ?? [], hasMoreResults: data.hasMoreResults ?? false }, null, 2);
+    }
+
+    case "list_cantons": {
+      // ZEFIX /cantons and /legalForms endpoints require authentication (403).
+      // Return hardcoded authoritative list instead.
+      const cantons = [
+        { code: "AG", name: "Aargau" }, { code: "AI", name: "Appenzell Innerrhoden" },
+        { code: "AR", name: "Appenzell Ausserrhoden" }, { code: "BE", name: "Bern" },
+        { code: "BL", name: "Basel-Landschaft" }, { code: "BS", name: "Basel-Stadt" },
+        { code: "FR", name: "Fribourg" }, { code: "GE", name: "Geneva" },
+        { code: "GL", name: "Glarus" }, { code: "GR", name: "Graubünden" },
+        { code: "JU", name: "Jura" }, { code: "LU", name: "Lucerne" },
+        { code: "NE", name: "Neuchâtel" }, { code: "NW", name: "Nidwalden" },
+        { code: "OW", name: "Obwalden" }, { code: "SG", name: "St. Gallen" },
+        { code: "SH", name: "Schaffhausen" }, { code: "SO", name: "Solothurn" },
+        { code: "SZ", name: "Schwyz" }, { code: "TG", name: "Thurgau" },
+        { code: "TI", name: "Ticino" }, { code: "UR", name: "Uri" },
+        { code: "VD", name: "Vaud" }, { code: "VS", name: "Valais" },
+        { code: "ZG", name: "Zug" }, { code: "ZH", name: "Zürich" },
+      ];
+      return JSON.stringify(cantons, null, 2);
+    }
+
+    case "list_legal_forms": {
+      // ZEFIX /legalForms requires authentication (403). Return common Swiss legal forms.
+      const forms = [
+        { code: "0101", name: "Einzelunternehmen", nameEn: "Sole proprietorship" },
+        { code: "0103", name: "Kollektivgesellschaft", nameEn: "General partnership" },
+        { code: "0104", name: "Kommanditgesellschaft", nameEn: "Limited partnership" },
+        { code: "0105", name: "Aktiengesellschaft (AG)", nameEn: "Corporation (AG)" },
+        { code: "0106", name: "Gesellschaft mit beschränkter Haftung (GmbH)", nameEn: "Limited liability company (GmbH)" },
+        { code: "0107", name: "Genossenschaft", nameEn: "Cooperative" },
+        { code: "0108", name: "Verein", nameEn: "Association" },
+        { code: "0109", name: "Stiftung", nameEn: "Foundation" },
+        { code: "0110", name: "Kommanditaktiengesellschaft", nameEn: "Partnership limited by shares" },
+        { code: "0113", name: "Filiale ausländischer Gesellschaft", nameEn: "Branch of foreign company" },
+        { code: "0114", name: "Institut des öffentlichen Rechts", nameEn: "Public law institution" },
+      ];
+      return JSON.stringify(forms, null, 2);
+    }
+
+    default:
+      throw new Error(`Unknown companies tool: ${name}`);
+  }
+}

package/src/modules/geodata.ts

@@ -0,0 +1,179 @@
+import { fetchJSON, buildUrl } from "../utils/http.js";
+
+const BASE = "https://api3.geo.admin.ch";
+
+export const geodataTools = [
+  {
+    name: "geocode",
+    description: "Convert a Swiss address or place name to coordinates (swisstopo)",
+    inputSchema: {
+      type: "object",
+      required: ["address"],
+      properties: {
+        address: { type: "string", description: "Swiss address or place name" },
+      },
+    },
+  },
+  {
+    name: "reverse_geocode",
+    description: "Convert coordinates to a Swiss address (swisstopo)",
+    inputSchema: {
+      type: "object",
+      required: ["lat", "lng"],
+      properties: {
+        lat: { type: "number", description: "Latitude (WGS84)" },
+        lng: { type: "number", description: "Longitude (WGS84)" },
+      },
+    },
+  },
+  {
+    name: "search_places",
+    description: "Search Swiss place names, localities, mountains, and geographic features",
+    inputSchema: {
+      type: "object",
+      required: ["query"],
+      properties: {
+        query: { type: "string", description: "Place name to search" },
+        type: { type: "string", description: "Type filter: locations, featuresearch" },
+      },
+    },
+  },
+  {
+    name: "get_solar_potential",
+    description: "Get rooftop solar energy potential for a location in Switzerland",
+    inputSchema: {
+      type: "object",
+      required: ["lat", "lng"],
+      properties: {
+        lat: { type: "number", description: "Latitude (WGS84)" },
+        lng: { type: "number", description: "Longitude (WGS84)" },
+      },
+    },
+  },
+  {
+    name: "identify_location",
+    description: "Identify geographic features and data layers at a specific Swiss location",
+    inputSchema: {
+      type: "object",
+      required: ["lat", "lng"],
+      properties: {
+        lat: { type: "number", description: "Latitude (WGS84)" },
+        lng: { type: "number", description: "Longitude (WGS84)" },
+        layers: { type: "string", description: "Comma-separated layer ids (default: all visible)" },
+      },
+    },
+  },
+  {
+    name: "get_municipality",
+    description: "Get information about a Swiss municipality by name",
+    inputSchema: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: { type: "string", description: "Municipality name" },
+      },
+    },
+  },
+];
+
+// Convert WGS84 to LV95 (Swiss projection) — approximate
+function wgs84ToLV95(lat: number, lng: number): { x: number; y: number } {
+  // Approx conversion for API calls that need Swiss coords
+  const phiPrime = (lat * 3600 - 169028.66) / 10000;
+  const lambdaPrime = (lng * 3600 - 26782.5) / 10000;
+  const E = 2600072.37
+    + 211455.93 * lambdaPrime
+    - 10938.51 * lambdaPrime * phiPrime
+    - 0.36 * lambdaPrime * phiPrime ** 2
+    - 44.54 * lambdaPrime ** 3;
+  const N = 1200147.07
+    + 308807.95 * phiPrime
+    + 3745.25 * lambdaPrime ** 2
+    + 76.63 * phiPrime ** 2
+    - 194.56 * lambdaPrime ** 2 * phiPrime
+    + 119.79 * phiPrime ** 3;
+  return { x: E, y: N };
+}
+
+export async function handleGeodata(name: string, args: Record<string, unknown>): Promise<string> {
+  switch (name) {
+    case "geocode":
+    case "search_places": {
+      const url = buildUrl(`${BASE}/rest/services/api/SearchServer`, {
+        searchText: args.address as string ?? args.query as string,
+        type: args.type as string ?? "locations",
+        sr: 4326,
+        limit: 10,
+      });
+      const data = await fetchJSON<unknown>(url);
+      return JSON.stringify(data, null, 2);
+    }
+
+    case "reverse_geocode": {
+      const lat = args.lat as number;
+      const lng = args.lng as number;
+      const { x, y } = wgs84ToLV95(lat, lng);
+      const extent = `${x - 100},${y - 100},${x + 100},${y + 100}`;
+      const url = buildUrl(`${BASE}/rest/services/api/SearchServer`, {
+        searchText: `${lat},${lng}`,
+        type: "locations",
+        sr: 4326,
+        limit: 5,
+      });
+      void extent; // extent used in identify, not reverse geocode search
+      const data = await fetchJSON<unknown>(url);
+      return JSON.stringify(data, null, 2);
+    }
+
+    case "get_solar_potential": {
+      const lat = args.lat as number;
+      const lng = args.lng as number;
+      const extent = `${lng - 0.05},${lat - 0.05},${lng + 0.05},${lat + 0.05}`;
+      const url = buildUrl(`${BASE}/rest/services/all/MapServer/identify`, {
+        geometry: `${lng},${lat}`,
+        geometryType: "esriGeometryPoint",
+        layers: "all:ch.bfe.solarenergie-eignung-daecher",
+        mapExtent: extent,
+        imageDisplay: "500,500,96",
+        tolerance: 100,
+        sr: 4326,
+        returnGeometry: false,
+      });
+      const data = await fetchJSON<unknown>(url);
+      return JSON.stringify(data, null, 2);
+    }
+
+    case "identify_location": {
+      const lat = args.lat as number;
+      const lng = args.lng as number;
+      const extent = `${lng - 0.05},${lat - 0.05},${lng + 0.05},${lat + 0.05}`;
+      const layers = args.layers ? `all:${args.layers}` : "all";
+      const url = buildUrl(`${BASE}/rest/services/all/MapServer/identify`, {
+        geometry: `${lng},${lat}`,
+        geometryType: "esriGeometryPoint",
+        layers,
+        mapExtent: extent,
+        imageDisplay: "500,500,96",
+        tolerance: 5,
+        sr: 4326,
+        returnGeometry: false,
+      });
+      const data = await fetchJSON<unknown>(url);
+      return JSON.stringify(data, null, 2);
+    }
+
+    case "get_municipality": {
+      const url = buildUrl(`${BASE}/rest/services/api/SearchServer`, {
+        searchText: args.name as string,
+        type: "locations",
+        sr: 4326,
+        limit: 5,
+      });
+      const data = await fetchJSON<unknown>(url);
+      return JSON.stringify(data, null, 2);
+    }
+
+    default:
+      throw new Error(`Unknown geodata tool: ${name}`);
+  }
+}

package/src/modules/transport.ts

@@ -0,0 +1,138 @@
+import { fetchJSON, buildUrl } from "../utils/http.js";
+
+const BASE = "https://transport.opendata.ch/v1";
+
+export const transportTools = [
+  {
+    name: "search_stations",
+    description: "Search for Swiss public transport stations/stops by name or coordinates",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Station name to search for" },
+        x: { type: "number", description: "Longitude (WGS84)" },
+        y: { type: "number", description: "Latitude (WGS84)" },
+        type: { type: "string", description: "Filter: all, station, poi, address" },
+      },
+    },
+  },
+  {
+    name: "get_connections",
+    description: "Get train/bus connections between two Swiss locations",
+    inputSchema: {
+      type: "object",
+      required: ["from", "to"],
+      properties: {
+        from: { type: "string", description: "Departure station/address" },
+        to: { type: "string", description: "Arrival station/address" },
+        date: { type: "string", description: "Date YYYY-MM-DD (default: today)" },
+        time: { type: "string", description: "Time HH:MM (default: now)" },
+        limit: { type: "number", description: "Number of connections (1-16, default: 4)" },
+        isArrivalTime: { type: "boolean", description: "True if time is arrival time" },
+      },
+    },
+  },
+  {
+    name: "get_departures",
+    description: "Get live departures from a Swiss transport station",
+    inputSchema: {
+      type: "object",
+      required: ["station"],
+      properties: {
+        station: { type: "string", description: "Station name" },
+        limit: { type: "number", description: "Number of departures (default: 10)" },
+        datetime: { type: "string", description: "DateTime YYYY-MM-DDTHH:MM (default: now)" },
+      },
+    },
+  },
+  {
+    name: "get_arrivals",
+    description: "Get live arrivals at a Swiss transport station",
+    inputSchema: {
+      type: "object",
+      required: ["station"],
+      properties: {
+        station: { type: "string", description: "Station name" },
+        limit: { type: "number", description: "Number of arrivals (default: 10)" },
+        datetime: { type: "string", description: "DateTime YYYY-MM-DDTHH:MM (default: now)" },
+      },
+    },
+  },
+  {
+    name: "get_nearby_stations",
+    description: "Find Swiss public transport stations near given coordinates",
+    inputSchema: {
+      type: "object",
+      required: ["x", "y"],
+      properties: {
+        x: { type: "number", description: "Longitude (WGS84)" },
+        y: { type: "number", description: "Latitude (WGS84)" },
+        limit: { type: "number", description: "Number of results (default: 10)" },
+        distance: { type: "number", description: "Max distance in meters" },
+      },
+    },
+  },
+];
+
+export async function handleTransport(name: string, args: Record<string, unknown>): Promise<string> {
+  switch (name) {
+    case "search_stations": {
+      const url = buildUrl(`${BASE}/locations`, {
+        query: args.query as string,
+        x: args.x as number,
+        y: args.y as number,
+        type: args.type as string,
+      });
+      const data = await fetchJSON<{ stations: unknown[] }>(url);
+      return JSON.stringify(data.stations, null, 2);
+    }
+
+    case "get_connections": {
+      const url = buildUrl(`${BASE}/connections`, {
+        from: args.from as string,
+        to: args.to as string,
+        date: args.date as string,
+        time: args.time as string,
+        limit: args.limit as number,
+        isArrivalTime: args.isArrivalTime ? 1 : undefined,
+      });
+      const data = await fetchJSON<{ connections: unknown[] }>(url);
+      return JSON.stringify(data.connections, null, 2);
+    }
+
+    case "get_departures": {
+      const url = buildUrl(`${BASE}/stationboard`, {
+        station: args.station as string,
+        limit: args.limit as number,
+        datetime: args.datetime as string,
+        type: "departure",
+      });
+      const data = await fetchJSON<{ station: unknown; stationboard: unknown[] }>(url);
+      return JSON.stringify({ station: data.station, departures: data.stationboard }, null, 2);
+    }
+
+    case "get_arrivals": {
+      const url = buildUrl(`${BASE}/stationboard`, {
+        station: args.station as string,
+        limit: args.limit as number,
+        datetime: args.datetime as string,
+        type: "arrival",
+      });
+      const data = await fetchJSON<{ station: unknown; stationboard: unknown[] }>(url);
+      return JSON.stringify({ station: data.station, arrivals: data.stationboard }, null, 2);
+    }
+
+    case "get_nearby_stations": {
+      const url = buildUrl(`${BASE}/locations`, {
+        x: args.x as number,
+        y: args.y as number,
+        type: "station",
+      });
+      const data = await fetchJSON<{ stations: unknown[] }>(url);
+      return JSON.stringify(data.stations, null, 2);
+    }
+
+    default:
+      throw new Error(`Unknown transport tool: ${name}`);
+  }
+}