openrouteservice-mcp 1.0.0

package/README.md

@@ -0,0 +1,13 @@
+# openrouteservice-mcp
+
+Query OpenRouteService (free key; set OPENROUTESERVICE_API_KEY): geocode, reverse geocode, driving directions.
+
+## Tools
+
+- `geocode` — Forward geocode a place name.
+- `reverse` — Place name for coordinates.
+- `directions` — Car route between two points.
+
+## Source
+
+[openrouteservice-mcp](https://github.com/mrfentmen/premium-mcps/tree/main/servers/openrouteservice-mcp)

package/dist/api.d.ts

@@ -0,0 +1,7 @@
+export declare class OrsError extends Error {
+    constructor(message: string);
+}
+export declare function errorMessage(e: unknown): string;
+export declare function geocode(query: string, limit?: string): Promise<string>;
+export declare function reverse(lat: string, lon: string): Promise<string>;
+export declare function directions(fromLon: string, fromLat: string, toLon: string, toLat: string): Promise<string>;

package/dist/api.js

@@ -0,0 +1,59 @@
+export class OrsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "OrsError";
+    }
+}
+export function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+const UA = { "User-Agent": "awesome-mcps/1.0" };
+function key() {
+    const k = process.env.OPENROUTESERVICE_API_KEY;
+    if (!k)
+        throw new OrsError("Set OPENROUTESERVICE_API_KEY (free openrouteservice key).");
+    return k;
+}
+async function get(path) {
+    const sep = path.includes("?") ? "&" : "?";
+    let res;
+    try {
+        res = await fetch(`https://api.openrouteservice.org${path}${sep}api_key=${encodeURIComponent(key())}`, {
+            headers: { ...UA, Accept: "application/json" },
+            signal: AbortSignal.timeout(25000),
+        });
+    }
+    catch (e) {
+        throw new OrsError(`Network error: ${e.message}`);
+    }
+    if (!res.ok) {
+        const body = (await res.text()).slice(0, 300);
+        throw new OrsError(`HTTP ${res.status}: ${body}`);
+    }
+    return (await res.text()).slice(0, 12000);
+}
+export function geocode(query, limit) {
+    const n = Math.min(Number(limit ?? 5) || 5, 20);
+    return get(`/geocode/search?text=${encodeURIComponent(query)}&size=${n}`);
+}
+export function reverse(lat, lon) {
+    return get(`/geocode/reverse?point.lat=${encodeURIComponent(lat)}&point.lon=${encodeURIComponent(lon)}&size=1`);
+}
+export async function directions(fromLon, fromLat, toLon, toLat) {
+    let res;
+    try {
+        res = await fetch("https://api.openrouteservice.org/v2/directions/driving-car", {
+            method: "POST",
+            headers: { ...UA, Accept: "application/json", "Content-Type": "application/json", Authorization: key() },
+            body: JSON.stringify({ coordinates: [[Number(fromLon), Number(fromLat)], [Number(toLon), Number(toLat)]] }),
+            signal: AbortSignal.timeout(25000),
+        });
+    }
+    catch (e) {
+        throw new OrsError(`Network error: ${e.message}`);
+    }
+    const text = await res.text();
+    if (!res.ok)
+        throw new OrsError(`HTTP ${res.status}: ${text.slice(0, 300)}`);
+    return text.slice(0, 8000);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,12 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP server running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createServer(): McpServer;

package/dist/server.js

@@ -0,0 +1,63 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { errorMessage, geocode, reverse, directions, } from "./api.js";
+const text = (t) => ({ content: [{ type: "text", text: t }] });
+const textError = (t) => ({ content: [{ type: "text", text: t }], isError: true });
+const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
+export function createServer() {
+    const server = new McpServer({
+        name: "openrouteservice-mcp",
+        version: "1.0.0",
+    });
+    server.registerTool("geocode", {
+        title: "Geocode",
+        description: "Forward geocode a place name.",
+        inputSchema: z.object({
+            query: z.string().describe("Place name, e.g. Berlin."),
+            limit: z.string().describe("Max results (default 5, max 20).").optional()
+        }),
+        annotations: READ_ONLY,
+    }, async ({ query, limit }) => {
+        try {
+            return text(await geocode(query, limit));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("reverse", {
+        title: "Reverse geocode",
+        description: "Place name for coordinates.",
+        inputSchema: z.object({
+            lat: z.string().describe("Latitude."),
+            lon: z.string().describe("Longitude.")
+        }),
+        annotations: READ_ONLY,
+    }, async ({ lat, lon }) => {
+        try {
+            return text(await reverse(lat, lon));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("directions", {
+        title: "Driving directions",
+        description: "Car route between two points.",
+        inputSchema: z.object({
+            from_lon: z.string().describe("Origin longitude."),
+            from_lat: z.string().describe("Origin latitude."),
+            to_lon: z.string().describe("Destination longitude."),
+            to_lat: z.string().describe("Destination latitude.")
+        }),
+        annotations: READ_ONLY,
+    }, async ({ from_lon, from_lat, to_lon, to_lat }) => {
+        try {
+            return text(await directions(from_lon, from_lat, to_lon, to_lat));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    return server;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "openrouteservice-mcp",
+  "version": "1.0.0",
+  "description": "OpenRouteService geocoding and routing. Free key.",
+  "type": "module",
+  "mcpName": "io.github.mrfentmen/openrouteservice-mcp",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mrfentmen/premium-mcps.git"
+  },
+  "bin": {
+    "openrouteservice-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "dev": "rm -rf dist && tsc -p tsconfig.json && node dist/index.js",
+    "inspect": "npx @modelcontextprotocol/inspector node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "openrouteservice",
+    "geocoding",
+    "routing",
+    "maps"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}