campertunity-mcp-server 0.0.1

package/README.md

@@ -0,0 +1,131 @@
+# MCP Server for Campertunity
+
+This server implements the Model Context Protocol (MCP) for Campertunity, providing AI models with tools to interact with camping and outdoor recreation data.
+
+## MCP Client Config
+
+```
+{
+  "mcpServers": {
+    "mcp-campertunity-local": {
+      "command": "node",
+      "args": ["/path/to/project/dist/index.js"],
+      "env": {
+        "CAMPERTUNITY_API_KEY": "your_api_key_here",
+      }
+    }
+  }
+}
+```
+
+
+## Setup
+
+1. Get your API key from [https://campertunity.com/mcp](https://campertunity.com/mcp)
+2. Set the environment variable:
+   ```
+   CAMPERTUNITY_API_KEY=your_api_key_here
+   ```
+
+## Available Tools
+
+### place-search
+Search for camping places with various filters and criteria.
+- **Parameters:**
+  - `limit`: Number of results (default: 50, max: 1000)
+  - `startDate`: Start date for availability (YYYY-MM-DD)
+  - `endDate`: End date for availability (YYYY-MM-DD)
+  - `adults`: Number of adults (default: 1)
+  - `children`: Number of children (default: 0)
+  - `latitude`: Center point latitude
+  - `longitude`: Center point longitude
+  - `radius`: Search radius in kilometers (default: 20)
+  - `filters`: Array of tags to filter by (see Tag enum below)
+  - `campgroundDescription`: Natural language description of desired campground features
+
+### place-details
+Get detailed information about a specific camping place.
+- **Parameters:**
+  - `placeId`: ID of the place to get details for
+
+### place-availability
+Check availability of camping sites at a specific place.
+- **Parameters:**
+  - `placeId`: ID of the place to check
+  - `siteIds`: Optional array of specific site IDs to check
+  - `startDate`: Start date (YYYY-MM-DD)
+  - `endDate`: End date (YYYY-MM-DD)
+
+### place-book
+Book a camping site.
+- **Parameters:**
+  - `placeId`: ID of the place to book
+  - `startDate`: Start date (YYYY-MM-DD)
+  - `endDate`: End date (YYYY-MM-DD)
+  - `adults`: Number of adults (default: 1)
+  - `children`: Number of children (default: 0)
+
+## Available Tags for Filtering
+
+### Site Types
+- tent
+- rv
+- lodging
+- glamping
+- cabin
+
+### Access Types
+- driveIn
+- walkIn
+- equestrian
+- boat
+
+### Activities
+- biking
+- boating
+- fishing
+- hiking
+- horsebackRiding
+- paddling
+- windSports
+- surfing
+- swimming
+- whitewaterPaddling
+- wildlifeWatching
+
+### Amenities
+- picnicTable
+- fires
+- toilets
+- outhouse
+- potableWater
+- petFriendly
+- rvHookup
+- rvSanitation
+- trash
+- showers
+- wifi
+- handicap
+
+### Terrain
+- beach
+- cave
+- desert
+- forest
+- hotSpring
+- lake
+- river
+- swimmingHole
+- waterfall
+- creek
+
+## Important Notice
+
+The data provided through these tools is collected from multiple sources and enhanced with AI. To ensure data accuracy and respect intellectual property rights:
+
+- Do not redistribute the data
+- Do not save or cache the data
+- Do not modify the data
+- Always use real-time data through the server
+
+For more information, visit [campertunity.com](https://campertunity.com)

package/dist/campertunity/client.js

@@ -0,0 +1,34 @@
+const CAMPERTUNITY_API_URL = process.env.CAMPERTUNITY_API_URL || "https://us-central1-my-project-1517611279378.cloudfunctions.net/public/api";
+const CAMPERTUNITY_API_KEY = process.env.CAMPERTUNITY_API_KEY;
+if (!CAMPERTUNITY_API_KEY) {
+    throw new Error("CAMPERTUNITY_API_KEY environment variable is required");
+}
+export class CampertunityClient {
+    async get(path) {
+        const response = await fetch(`${CAMPERTUNITY_API_URL}${path}`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${CAMPERTUNITY_API_KEY}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Campertunity API error: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async post(path, data) {
+        const response = await fetch(`${CAMPERTUNITY_API_URL}${path}`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${CAMPERTUNITY_API_KEY}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(data),
+        });
+        if (!response.ok) {
+            throw new Error(`Campertunity API error: ${response.statusText}`);
+        }
+        return response.json();
+    }
+}
+export const campertunityClient = new CampertunityClient();

package/dist/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CampertunityClient } from "./campertunity/client.js";
+import { placeAvailabilityTool } from "./tools/place_availability.js";
+import { placeBookTool } from "./tools/place_book.js";
+import { placeDetailsTool } from "./tools/place_details.js";
+import { placeSearchTool } from "./tools/place_search.js";
+const campertunityClient = new CampertunityClient();
+const server = new McpServer({
+    name: "campertunity-model-context-protocol-server",
+    version: "0.0.1",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+placeAvailabilityTool(server, campertunityClient);
+placeBookTool(server, campertunityClient);
+placeDetailsTool(server, campertunityClient);
+placeSearchTool(server, campertunityClient);
+async function runServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Campertunity MCP Server running on stdio");
+}
+runServer().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/tools/place_availability.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export const placeAvailabilityTool = (server, campertunityClient) => {
+    server.tool('place-availability', {
+        placeId: z.string().describe('The id of the place to check availability for.'),
+        siteIds: z.array(z.string()).optional().describe('The ids of the sites to check availability for.'),
+        startDate: z.string().describe('The start date to check availability for. Format: YYYY-MM-DD'),
+        endDate: z.string().describe('The end date to check availability for. Format: YYYY-MM-DD'),
+    }, async ({ placeId, siteIds, startDate, endDate }) => {
+        try {
+            const availability = await campertunityClient.post(`/place/availability`, {
+                placeId,
+                siteIds,
+                startDate,
+                endDate,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(availability), mimeType: 'application/json' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: 'Error: ' + error.message }],
+                isError: true,
+            };
+        }
+    });
+};

package/dist/tools/place_book.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export const placeBookTool = (server, campertunityClient) => {
+    server.tool('place-book', {
+        placeId: z.string().describe('The id of the place to book.'),
+        startDate: z.string().optional().describe('The start date of the booking. Format: YYYY-MM-DD'),
+        endDate: z.string().optional().describe('The end date of the booking. Format: YYYY-MM-DD'),
+        adults: z.number().default(1).describe('Number of adults. Default is 1.'),
+        children: z.number().default(0).describe('Number of children. Default is 0.'),
+    }, async ({ placeId, startDate, endDate, adults, children }) => {
+        try {
+            const availability = await campertunityClient.post(`/place/book`, {
+                placeId,
+                startDate,
+                endDate,
+                adults,
+                children,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(availability), mimeType: 'application/json' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: 'Error: ' + error.message }],
+                isError: true,
+            };
+        }
+    });
+};

package/dist/tools/place_details.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+// NOTE: This is a tool since tools are more supported by the MCP protocol
+export const placeDetailsTool = (server, campertunityClient) => {
+    server.tool('place-details', {
+        placeId: z.string().describe('The id of the place to get details for.'),
+    }, async ({ placeId }) => {
+        try {
+            const place = await campertunityClient.get(`/place/${placeId}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(place),
+                        mimeType: 'application/json',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: 'Error: ' + error.message }],
+                isError: true,
+            };
+        }
+    });
+};

package/dist/tools/place_search.js

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+export var Tag;
+(function (Tag) {
+    // SiteType
+    Tag["tent"] = "tent";
+    Tag["rv"] = "rv";
+    Tag["lodging"] = "lodging";
+    Tag["glamping"] = "glamping";
+    Tag["cabin"] = "cabin";
+    // AccessType
+    Tag["driveIn"] = "driveIn";
+    Tag["walkIn"] = "walkIn";
+    Tag["equestrian"] = "equestrian";
+    Tag["boat"] = "boat";
+    // Activities
+    Tag["biking"] = "biking";
+    Tag["boating"] = "boating";
+    Tag["fishing"] = "fishing";
+    Tag["hiking"] = "hiking";
+    Tag["horsebackRiding"] = "horsebackRiding";
+    Tag["paddling"] = "paddling";
+    Tag["windSports"] = "windSports";
+    Tag["surfing"] = "surfing";
+    Tag["swimming"] = "swimming";
+    Tag["whitewaterPaddling"] = "whitewaterPaddling";
+    Tag["wildlifeWatching"] = "wildlifeWatching";
+    // Amenities
+    Tag["picnicTable"] = "picnicTable";
+    Tag["fires"] = "fires";
+    Tag["toilets"] = "toilets";
+    Tag["outhouse"] = "outhouse";
+    Tag["potableWater"] = "potableWater";
+    Tag["petFriendly"] = "petFriendly";
+    Tag["rvHookup"] = "rvHookup";
+    Tag["rvSanitation"] = "rvSanitation";
+    Tag["trash"] = "trash";
+    Tag["showers"] = "showers";
+    Tag["wifi"] = "wifi";
+    Tag["handicap"] = "handicap";
+    // Terrain
+    Tag["beach"] = "beach";
+    Tag["cave"] = "cave";
+    Tag["desert"] = "desert";
+    Tag["forest"] = "forest";
+    Tag["hotSpring"] = "hotSpring";
+    Tag["lake"] = "lake";
+    Tag["river"] = "river";
+    Tag["swimmingHole"] = "swimmingHole";
+    Tag["waterfall"] = "waterfall";
+    Tag["creek"] = "creek";
+})(Tag || (Tag = {}));
+export const placeSearchTool = (server, campertunityClient) => {
+    server.tool('place-search', {
+        limit: z.number().default(50).optional().describe('Number of places to return. Default is 50, max is 1000.'),
+        startDate: z.string().optional().describe('Start date for availability search. Format: YYYY-MM-DD'),
+        endDate: z.string().optional().describe('End date for availability search. Format: YYYY-MM-DD'),
+        adults: z.number().optional().describe('Number of adults. Default is 1.'),
+        children: z.number().optional().describe('Number of children. Default is 0.'),
+        latitude: z.number().optional().describe('Latitude to filter by.'),
+        longitude: z.number().optional().describe('Longitude to filter by.'),
+        radius: z.number().optional().default(20).describe('Radius to filter by (in km).'),
+        filters: z.array(z.enum(Object.values(Tag))).optional().describe('Filter out places that have specific tags.'),
+        campgroundDescription: z.string().optional().describe('Describe the campground you are looking for. Note: not the location, but something about the campground like "has a pool" or "near a lake" or "has a playground"'),
+    }, async ({ limit, startDate, endDate, adults, children, latitude, longitude, radius, filters, campgroundDescription }) => {
+        try {
+            const params = new URLSearchParams();
+            if (limit)
+                params.set('limit', limit.toString());
+            if (startDate)
+                params.set('startDate', startDate);
+            if (endDate)
+                params.set('endDate', endDate);
+            if (adults)
+                params.set('adults', adults.toString());
+            if (children)
+                params.set('children', children.toString());
+            if (latitude)
+                params.set('latitude', latitude.toString());
+            if (longitude)
+                params.set('longitude', longitude.toString());
+            if (radius)
+                params.set('radius', radius.toString());
+            if (filters)
+                params.set('filters', filters.join(','));
+            if (campgroundDescription)
+                params.set('campgroundDescription', campgroundDescription);
+            const places = await campertunityClient.get(`/place/search?${params.toString()}`);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(places), mimeType: 'application/json' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: 'Error: ' + error.message }],
+                isError: true,
+            };
+        }
+    });
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "campertunity-mcp-server",
+  "version": "0.0.1",
+  "description": "MCP Server for Campertunity - A Model Context Protocol server for interacting with camping and outdoor recreation data",
+  "type": "module",
+  "bin": {
+    "mcp-campertunity-server": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "prepare": "npm run build",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "campertunity",
+    "camping",
+    "outdoor",
+    "recreation",
+    "ai",
+    "model-context-protocol"
+  ],
+  "author": "Campertunity",
+  "license": "AGPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/campertunity/mcp-server"
+  },
+  "bugs": {
+    "url": "https://github.com/campertunity/mcp-server/issues"
+  },
+  "homepage": "https://campertunity.com",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.7.0",
+    "@types/node": "^22"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "shx": "^0.3.4",
+    "typescript": "^5.8.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}