_ registry / mcp streamable-http · checked just now

meridian-dispatch

https://www.meridiandispatch.com

Registry code: e7454ff8a1b9af1f

api record

Meridian Dispatch is a travel reference publisher: guides to countries, towns, venues, trails, ski resorts and events, written for travellers deciding where to go and how to do it. Start with `search_guides` when you do not know the exact page; use `get_destination` for a country or town (a short overview with ranked place ids by default; `detail: "full"` for the whole guide), `get_place` for a single sight, trail, event or ski resort, `get_dispatch` for a long-form dispatch or a day-by-day itinerary, `list_events` for festivals by month, `list_best_places` for ranked top-places lists,…

endpoint
https://www.meridiandispatch.com/api/mcp
protocol
streamable-http ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
0 · newcomer
_ is it live, free and safe measured by this hub
Is meridian-dispatch live?
Yes — it answered the hub's last check (checked just now). It answered 98% of checks over the last 30 days.
Is meridian-dispatch free to use?
Yes — the hub reached it with no key and no payment.
What tools does meridian-dispatch have?
20 tools: search_guides, create_itinerary_link, confirm_fact, get_my_account, get_dispatch, get_best_time, suggest_edit, get_plan, ….
Is meridian-dispatch safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
97.8%

90 days 97.9%· all time 97.9%

latency
1,209ms

last good check

priced tools
0

of 20 tools

_ answered our checks, 90 days 243 checks · signed record
  • degraded → live
  • live → degraded· timeout after 20000ms
  • degraded → live
  • live → degraded· timeout after 20000ms
  • degraded → live
_ what it is for
used for
  • get a travel destination guide
  • find best time to visit
  • list festivals by month
  • find places nearby
  • get ranked best places lists
takes → gives
text → text, data
tools
5 reads
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts. Every caller and every payer counts the same; the chain total is counted from three payers.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

_ what it can do 20 tools
2 open 18 never probed 2 of 20 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • get_destination reads open 40d ago

    Read the Meridian Dispatch guide to one country or one town, for planning a stay there. Returns: why go, how long to stay, the best months, getting there and around, practical FAQ answers, a structured fact sheet where one exists (nights, months, travel times in minutes, areas to stay, ranked top things, day trips, watch-outs), up to 15 ranked places worth your time with their own guide links, recommended hotels, the town guides of a country, which town meets which need where the country has a town-by-town comparison (where_to_stay_by_need, and compare on each town), related dispatches and a citation. Use it for "what to do in X", "how many days in X", "where to stay in X" or "which town in X for beaches". For a single sight, trail, event or ski resort use get_place; for a long-form dispatch use get_dispatch; to find a destination by theme use search_guides; for towns within reach use list_nearby. Two sizes: detail "summary" (the default) returns a short overview, nights, months, airports, areas to stay and the top 8 places, each with an id to pass to get_place as url; detail "full" returns everything above. Ask for "full" only when the summary lacks what the traveller needs. Matching tries a country first, then a town. A country with town guides but no country guide returns its town guides and dispatches instead. Read-only. An unknown name returns an error message.

    mcp-tool

    {
      "type": "object",
      "required": [
        "name"
      ],
      "properties": {
        "name": {
          "type": "string",
          "minLength": 1,
          "description": "One country or town, by English name, e.g. \"Slovenia\" or \"Bled\". Case and accents are ignored. Not a sight or region: use get_place or search_guides for those."
        },
        "detail": {
          "enum": [
            "summary",
            "full"
          ],
          "type": "string",
          "default": "summary",
          "description": "\"summary\" (default): a compact answer of a few thousand characters with place ids to drill into. \"full\": the whole guide (FAQ answers, full fact sheet, every ranked place, hotels), often over 15,000 characters."
        },
        "country": {
          "type": "string",
          "description": "The country of the town, by English name, to tell apart towns that share a name (Granada, Valencia, Mérida). Omit when name is a country or a unique town."
        }
      }
    }
    arguments 26 lines
  • list_events reads open 41d ago

    List the festivals and events worth planning a trip around, from the Meridian Dispatch events guide. Returns each event's name, kind, where it is, the current edition's dates (a label plus ISO start and end), the best day to go, when to book, the next edition where announced, a citable URL and a citation line, sorted by start date. With no filter it returns every event; month keeps events with any day in that month; country keeps one country. Use get_place with an event's URL for its full record (schedule, where to stay, tips). For every kind of destination in a month, not just events, use get_best_time. Read-only. Dates are for one edition, so check the page before booking. An invalid month or no match returns an error message.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "month": {
          "type": "string",
          "description": "An English month name (\"October\", or \"oct\") or its number, 1 to 12 (\"10\"). Keeps events with any day in that month. Omit for the whole year."
        },
        "region": {
          "enum": [
            "Europe",
            "Asia",
            "Middle East",
            "Africa",
            "North America",
            "Central America and the Caribbean",
            "South America",
            "Oceania"
          ],
          "type": "string",
          "description": "Only this part of the world. Use it for asks like \"festivals in Europe\"; country is more precise when the traveller names one."
        },
        "country": {
          "type": "string",
          "description": "Keep events in this country, by English name, e.g. \"Mexico\". Omit for every country."
        }
      }
    }
    arguments 27 lines
  • search_guides unknown never probed

    Search every Meridian Dispatch travel guide by keyword: long-form dispatches, multi-day itineraries, country and town guides, venues (sights, museums, beaches, parks), trails and scenic drives, events and ski resorts. Use it first when you do not know the exact page. Once you know the place, read it in full with get_destination (a country or town), get_place (one sight, trail, event or ski resort) or get_dispatch (a dispatch or itinerary); for ranked top-ten lists use list_best_places, for a month use get_best_time. Returns up to `limit` pages ranked by relevance, each with its type, title, country, town, a one-line summary, a citable URL and when it was last updated. Ranking is keyword-based with travel synonyms; a country or month named in the query is honoured. Read-only. When nothing matches it returns an error message; retry with a broader query or a place name.

    mcp-tool

    {
      "type": "object",
      "required": [
        "query"
      ],
      "properties": {
        "type": {
          "enum": [
            "dispatch",
            "itinerary",
            "country",
            "town",
            "town_compare",
            "venue",
            "trail",
            "event",
            "ski_resort",
            "museum",
            "airport"
          ],
          "type": "string",
          "description": "Return only one kind of page: dispatch (a reported long-form piece), itinerary (a multi-day country route), country or town (destination guides), town_compare (the towns of one country compared as places to stay, by need), venue (one sight), trail (a hike or scenic drive), event (a festival), ski_resort, museum (must-see works with their rooms and floors) or airport (how to get from the terminal to each town, airlines and routes, security, food, layovers). Omit to search all kinds."
        },
        "limit": {
          "type": "integer",
          "default": 8,
          "maximum": 20,
          "minimum": 1,
          "description": "Most results to return, 1 to 20. Defaults to 8."
        },
        "query": {
          "type": "string",
          "minLength": 1,
          "description": "What the traveller wants, in plain words: a place name (\"Kotor\"), an activity and a place (\"glacier hike Iceland\") or a theme (\"festivals in Japan\")."
        },
        "region": {
          "enum": [
            "Europe",
            "Asia",
            "Middle East",
            "Africa",
            "North America",
            "Central America and the Caribbean",
            "South America",
            "Oceania"
          ],
          "type": "string",
          "description": "Only this part of the world. Use it for asks like \"festivals in Europe\"; country is more precise when the traveller names one."
        },
        "country": {
          "type": "string",
          "description": "Return only pages in this country, by English name, e.g. \"Iceland\". Omit to search worldwide."
        }
      }
    }
    arguments 55 lines
  • create_itinerary_link reads unknown never probed

    Generate an itinerary import link: turn a day-by-day travel itinerary into a shareable "Add Itinerary to Meridian Dispatch" link. Use it only when the traveller wants a link to share or open elsewhere. To save a trip to the traveller's own account, privately, use create_plan (or edit_plan for one they have): that needs no link and can be deleted. To draft the plan itself, use get_destination, get_dispatch and get_place first and link places with their meridiandispatch.com URLs; for a trip the traveller will take themselves, read get_travel_preferences first (it needs sign-in) and fit the hotels, pace and routing to it. Opening the link on an iPhone with the Meridian Dispatch app shows the trip and adds it to the Plan tab as a new plan, after the traveller picks the first day; anywhere else it opens a web preview of the days. Days are numbered (day 1, 2, 3) or dated, and every day needs a hotel stay or its own city. A dated link opens on its dates, which the traveller can still move. When the dates are not negotiable (a trip built around a festival, a match, a concert or any event on fixed days), date every day and set fixed_dates: the app then adds the trip on exactly those dates with no date picker, and the link's page tells the traveller so. A place given with its meridiandispatch.com page URL arrives with that page's field record. Each call creates a new, public, permanent link that cannot be deleted (not idempotent). Anyone with it sees the trip's dates, towns, stops and hotel names; booking references, emails and phone numbers are removed. Tell the traveller this before making one. Returns the link, ready-made markdown, counts of days and items, and the places matched and not matched to the guides. An invalid itinerary returns an error listing every problem; too many links in an hour returns a rate-limit error.

    mcp-tool

    {
      "type": "object",
      "required": [
        "title",
        "country_code",
        "days"
      ],
      "properties": {
        "car": {
          "type": "object",
          "required": [
            "from_day",
            "to_day"
          ],
          "properties": {
            "pickup": {
              "type": "string",
              "pattern": "^[A-Za-z]{3}$",
              "description": "IATA code of the pick-up airport, when it is not airport."
            },
            "to_day": {
              "type": "integer",
              "minimum": 1,
              "description": "Day number of drop-off."
            },
            "dropoff": {
              "type": "string",
              "pattern": "^[A-Za-z]{3}$",
              "description": "IATA code of the drop-off airport, when it is not airport_home (or airport)."
            },
            "from_day": {
              "type": "integer",
              "minimum": 1,
              "description": "Day number of pick-up."
            }
          },
          "description": "A rental car the trip needs (a road trip, or days in the countryside). The app adds it as a car rental still to book and draws those days' travel as driving. from_day and to_day are day numbers on both numbered and dated itineraries; to_day may be the morning after the last day. Picked up and returned at airport and airport_home unless pickup or dropoff name other airports."
        },
        "days": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "items"
            ],
            "properties": {
              "day": {
                "type": "integer",
                "maximum": 30,
                "minimum": 1,
                "description": "Day number, from 1. Use this or date on every day."
              },
              "city": {
                "type": "string",
                "description": "Where the traveller is that day, e.g. \"Kotor\". Required unless a stay in stays covers this day."
              },
              "date": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                "description": "YYYY-MM-DD. Use this or day on every day."
              },
              "items": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "title"
                  ],
                  "properties": {
                    "lat": {
                      "type": "number",
                      "maximum": 90,
                      "minimum": -90,
                      "description": "Latitude, when there is no meridian_url, to about 100 m. A restaurant given with lat and lng lands on the app's map as itself, once the position is checked against the day's city (a coordinate more than about 50 km away is refused); without them it arrives as a meal to place."
                    },
                    "lng": {
                      "type": "number",
                      "maximum": 180,
                      "minimum": -180,
                      "description": "Longitude, with lat."
                    },
                    "url": {
                      "type": "string",
                      "maxLength": 300,
                      "description": "https only. The official page to book this stop: a restaurant's reservation page (its own site, or the booking service it uses: OpenTable, Resy, SevenRooms, TheFork, Tock), or a sight's or tour's own ticket shop. The app lists the stop in Still to book with BOOK opening this page. Never a reseller or a search page. Leave it out for a place that needs nothing booked."
                    },
                    "kind": {
                      "enum": [
                        "activity",
                        "restaurant",
                        "note"
                      ],
                      "type": "string",
                      "default": "activity",
                      "description": "activity (a place or thing to do), restaurant (somewhere to eat) or note (a reminder with no place)."
                    },
                    "note": {
                      "type": "string",
                      "maxLength": 500,
                      "description": "A tip for this stop."
                    },
                    "time": {
                      "type": "string",
                      "pattern": "^\\d{2}:\\d{2}$",
                      "description": "HH:MM, 24-hour."
                    },
                    "image": {
                      "type": "string",
                      "description": "A photograph of this stop from a Meridian Dispatch page (https://www.meridiandispatch.com/images/...), for a stop with no photo of its own: an event page's picture of the street fair, say. Any other host is refused."
                    },
                    "title": {
                      "type": "string",
                      "description": "The place or activity, e.g. \"Kotor Old Town\"."
                    },
                    "category": {
                      "type": "string",
                      "description": "The kind of place, e.g. \"Museum\" or \"Beach\"."
                    },
                    "part_of_day": {
                      "enum": [
                        "morning",
                        "afternoon",
                        "evening"
                      ],
                      "type": "string",
                      "description": "When in the day, if there is no exact time."
                    },
                    "meridian_url": {
                      "type": "string",
                      "description": "The meridiandispatch.com page for this place, when there is one (from search_guides or get_destination). The place then arrives with its location and record."
                    }
                  }
                },
                "maxItems": 15,
                "description": "The day's places and activities, in order."
              },
              "summary": {
                "type": "string",
                "maxLength": 300,
                "description": "One line about the day."
              },
              "country_code": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}$",
                "description": "ISO alpha-2, when this day is in a different country."
              }
            },
            "description": "One day. Give city unless a stay covers this day."
          },
          "maxItems": 30,
          "minItems": 1,
          "description": "The days in order, each with what to do. Number every day or date every day, not a mix. Every day needs its own city or a stay (in stays) whose check-in to check-out, inclusive, covers it; the error names each day with neither."
        },
        "stays": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "name"
            ],
            "properties": {
              "city": {
                "type": "string",
                "description": "The town the hotel is in."
              },
              "name": {
                "type": "string",
                "description": "The hotel's name, as booked."
              },
              "check_in": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                "description": "Dated itinerary: check-in date, YYYY-MM-DD."
              },
              "check_out": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                "description": "Dated itinerary: check-out date, YYYY-MM-DD."
              },
              "check_in_day": {
                "type": "integer",
                "minimum": 1,
                "description": "Numbered itinerary: the day number of check-in."
              },
              "check_out_day": {
                "type": "integer",
                "minimum": 2,
                "description": "Numbered itinerary: the day number of check-out."
              }
            }
          },
          "maxItems": 30,
          "description": "Where the traveller sleeps, by hotel name. Optional: a day not between a stay's check-in and check-out (inclusive) must give its own city, which places it in the app until a hotel is added. check_in_day and check_out_day on a numbered itinerary, check_in and check_out (YYYY-MM-DD) on a dated one."
        },
        "title": {
          "type": "string",
          "maxLength": 120,
          "minLength": 1,
          "description": "The trip, e.g. \"Six days on the Montenegro coast\"."
        },
        "airport": {
          "type": "string",
          "pattern": "^[A-Za-z]{3}$",
          "description": "IATA code of the airport to fly into, e.g. \"GDN\". The app books the flight in to it on day 1 instead of guessing (a country's busiest airport is often the wrong one: Warsaw for Gdańsk)."
        },
        "summary": {
          "type": "string",
          "maxLength": 400,
          "description": "One short paragraph shown under the title: what the trip is and why it works."
        },
        "fixed_dates": {
          "type": "boolean",
          "description": "true when the trip only works on its dates, e.g. it is built around an event. Needs a date on every day (not day numbers). The app imports it on those dates and the traveller cannot move them. Leave out for a trip that works any time."
        },
        "airport_home": {
          "type": "string",
          "pattern": "^[A-Za-z]{3}$",
          "description": "IATA code of the airport to fly home from, when it differs from airport."
        },
        "country_code": {
          "type": "string",
          "pattern": "^[A-Za-z]{2}$",
          "description": "ISO 3166 alpha-2 code of the main country, e.g. \"ME\"."
        }
      }
    }
    arguments 226 lines
  • confirm_fact unknown never probed

    Tell the Meridian Dispatch desk that a fact on one of its pages still holds, with the current, independent source that shows it (the place's official website, an operator or government page). Use it when the traveller confirms a fact on a page (they were just there, or asked you to check it and the source agrees). If the fact is wrong instead, use suggest_edit. Quote checked_text exactly as the page (or this server's answer) gives it and pass the source; a quote not on the page, or a source on meridiandispatch.com, is refused. A confirmation is recorded as a signal for the desk to review and counted per page; it does not mark the page verified, change its date or reorder any list, and the page itself does not change. The same confirmation sent twice is recorded once. Returns whether it was recorded.

    mcp-tool

    {
      "type": "object",
      "required": [
        "url",
        "checked_text",
        "source_url"
      ],
      "properties": {
        "url": {
          "type": "string",
          "maxLength": 300,
          "description": "The meridiandispatch.com page, as returned in source.url."
        },
        "source_url": {
          "type": "string",
          "maxLength": 300,
          "description": "Where you checked it: a current, authoritative page that is not on meridiandispatch.com."
        },
        "checked_text": {
          "type": "string",
          "maxLength": 500,
          "minLength": 4,
          "description": "The fact you checked, quoted from the page, e.g. a facts_to_check text."
        }
      }
    }
    arguments 26 lines
  • get_my_account unknown never probed

    The Meridian Dispatch account this connection is signed in to: the name (and email, unless the traveller hid it from Apple), when it was made, whether the app on a phone is signed in to it, its plan titles, and whether travel preferences are saved. Use it to confirm the account before editing, since a traveller can hold two Apple accounts. Needs sign-in.

    mcp-tool

    {
      "type": "object",
      "properties": {}
    }
    arguments 4 lines
  • get_dispatch reads unknown never probed

    Read one Meridian Dispatch long-form dispatch or multi-day itinerary. A dispatch is a reported piece on one place: returns its headline, standfirst, opening excerpt, themes, publish date, photo and links to its town and country guides (the full text stays on the page). An itinerary is a country route over several days: returns the bases in order, nights in each, where to stay and every day's activities by part of the day, each linked to its guide. Use it only for these two kinds of page. For a country or town guide use get_destination; for one sight, trail, event or ski resort use get_place; to list dispatches on a theme use search_guides with type "dispatch" or "itinerary". Lookup order: an exact URL, then an exact slug, then the single best keyword match, so a place name returns the one most relevant dispatch. Read-only. No match returns an error message.

    mcp-tool

    {
      "type": "object",
      "required": [
        "query"
      ],
      "properties": {
        "query": {
          "type": "string",
          "minLength": 1,
          "description": "A dispatch or itinerary URL, its slug (e.g. \"hallstatt\", \"montenegro-beach-six-days\"), or the place it covers (e.g. \"Hallstatt\")."
        }
      }
    }
    arguments 13 lines
  • get_best_time unknown never probed

    Get the best time to visit from the Meridian Dispatch guides, in one of two modes. Give destination (a country, town, trail or ski resort) for its best months, good and avoid months, closures and crowds where known, the guide's own best-time line, and the events held there. Or give month for "where to go in March": up to 40 countries, towns, trails, ski resorts and festivals the guides recommend that month, each with its reason, events first. If both are given, destination wins. For festival dates alone use list_events; for a full planning guide use get_destination. Read-only. An unknown destination, an invalid month or neither parameter returns an error message.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "month": {
          "type": "string",
          "description": "An English month name (\"October\", or \"oct\") or its number, 1 to 12 (\"10\"). Use this or destination."
        },
        "region": {
          "enum": [
            "Europe",
            "Asia",
            "Middle East",
            "Africa",
            "North America",
            "Central America and the Caribbean",
            "South America",
            "Oceania"
          ],
          "type": "string",
          "description": "With month: only this part of the world (\"where in Asia in February\"). Ignored with destination."
        },
        "destination": {
          "type": "string",
          "description": "A country, town, trail or ski resort, by name, e.g. \"Kotor\" or \"Niseko\". Use this or month."
        }
      }
    }
    arguments 27 lines
  • suggest_edit unknown never probed

    Send the Meridian Dispatch desk a correction to one of its pages. Use it when the traveller tells you something on a meridiandispatch.com page is wrong or out of date (a place has closed, moved, been renamed, changed its hours or now needs booking). Pass a source_url when the traveller gives one or one supports what they said. Do not use it for opinions, reviews or style. To read a page first, use get_place, get_destination or get_dispatch. Quote current_text exactly as it appears on the page (or in this server's answer about it); a quote that is not found is refused. Nothing changes immediately: the desk verifies every suggestion against its own sources before editing. Returns whether the suggestion was received and its id; the same suggestion sent twice is recorded once. A page that is not on meridiandispatch.com, a quote not on the page, or too many suggestions in an hour (per conversation, per address or per page) returns an error saying which.

    mcp-tool

    {
      "type": "object",
      "required": [
        "url",
        "current_text",
        "proposed_text",
        "reason"
      ],
      "properties": {
        "url": {
          "type": "string",
          "maxLength": 300,
          "description": "The meridiandispatch.com page to correct, as returned in source.url or canonical_url."
        },
        "field": {
          "enum": [
            "status",
            "hours",
            "location",
            "access",
            "dates",
            "name",
            "description",
            "other"
          ],
          "type": "string",
          "description": "What kind of fact is wrong: status (closed, reopened), hours, location, access (booking, tickets, transport), dates (an event), name, description, or other."
        },
        "reason": {
          "type": "string",
          "maxLength": 300,
          "minLength": 4,
          "description": "Why it is wrong, e.g. \"The traveller says it closed in spring 2026\" or \"The official site lists new hours\"."
        },
        "source_url": {
          "type": "string",
          "maxLength": 300,
          "description": "Optional: a page that supports the correction, ideally the place's own website. It speeds review."
        },
        "current_text": {
          "type": "string",
          "maxLength": 500,
          "minLength": 8,
          "description": "The wrong text, quoted exactly from the page or from this server's answer about it."
        },
        "proposed_text": {
          "type": "string",
          "maxLength": 500,
          "minLength": 2,
          "description": "What it should say instead, as plain text. Facts only, no prices."
        }
      }
    }
    arguments 53 lines
  • get_plan unknown never probed

    One of the signed-in traveller's plans, day by day: each day's date, town and stops (with each stop's id, time, minutes, category, visitNote (what the traveller does there that day), note (the place's advisory), ticketsURL (its booking page) and, for a table, tour or ticket, booked (true held, false still to book; a place with neither is JUST TURN UP, nothing to reserve)); a titleless freeform stop is marked role transfer, note or alternative), its bookings (with booked or still to book, and their details: a flight's airline, number, airports, terminals, seat and times; a hotel's address and check-in/out times; a train's operator and stations; a car rental's desks), and seq, the version to send back with edit_plan as base_seq. Needs sign-in.

    mcp-tool

    {
      "type": "object",
      "required": [
        "plan_id"
      ],
      "properties": {
        "plan_id": {
          "type": "string",
          "description": "The plan id from list_my_plans."
        }
      }
    }
    arguments 12 lines
  • list_nearby unknown never probed

    List the places Meridian Dispatch covers near a place or a coordinate, nearest first, for day trips from a base or what else to see near a sight. From a town with a researched guide, it leads with day_trips: the guide's own picks, with travel mode and how long. Without type it answers a day-trip question: up to 15 towns, each once at its nearest point, with its distance, summary, guide link, best few places and dispatches; a town's own sights are left out (get_destination has them). With type it returns a flat list of up to 20 places of that kind with distances. Distances are straight-line kilometres, not by road. Give place, or lat and lng together. For the sights inside one town use get_destination; to search by theme use search_guides. Read-only. An unknown place or nothing within the radius returns an error message.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "lat": {
          "type": "number",
          "maximum": 90,
          "minimum": -90,
          "description": "Latitude of the starting point in decimal degrees, e.g. 42.42. Give with lng, instead of place."
        },
        "lng": {
          "type": "number",
          "maximum": 180,
          "minimum": -180,
          "description": "Longitude of the starting point in decimal degrees, e.g. 18.77. Give with lat, instead of place."
        },
        "type": {
          "enum": [
            "dispatch",
            "itinerary",
            "country",
            "town",
            "town_compare",
            "venue",
            "trail",
            "event",
            "ski_resort",
            "museum",
            "airport"
          ],
          "type": "string",
          "description": "Return a flat list of only this kind of place, e.g. \"trail\" or \"event\". Omit for the day-trip view grouped by town."
        },
        "place": {
          "type": "string",
          "description": "The starting point: a place name or meridiandispatch.com URL, e.g. \"Kotor\". Use this, or lat and lng."
        },
        "radius_km": {
          "type": "number",
          "default": 40,
          "maximum": 200,
          "minimum": 1,
          "description": "How far to look, in straight-line kilometres, 1 to 200. Defaults to 40; use 60 to 100 for a day trip by car."
        }
      }
    }
    arguments 45 lines
  • suggest_place unknown never probed

    Suggest a town, sight, walk, museum, event, ski resort, food area or hotel that Meridian Dispatch has no page for, so the desk can research and add it to this free, shared travel reference. Use it only when the traveller asks you to, or agrees when you offer, for somewhere the guides do not cover (search_guides or get_destination found nothing) that is real and open. Do not call it on your own for places you recommend or put in a plan. Single restaurants, bars and shops are not listed; a food street, market or bar district is. source_url is required: the place's official website or another current page showing it exists. A place already covered returns its page instead of a suggestion. Nothing is published straight away: the desk researches every suggestion first. The same place suggested twice is recorded once. Returns whether it was received.

    mcp-tool

    {
      "type": "object",
      "required": [
        "name",
        "country",
        "why",
        "source_url"
      ],
      "properties": {
        "lat": {
          "type": "number",
          "maximum": 90,
          "minimum": -90,
          "description": "Latitude, if known."
        },
        "lng": {
          "type": "number",
          "maximum": 180,
          "minimum": -180,
          "description": "Longitude, if known."
        },
        "why": {
          "type": "string",
          "maxLength": 400,
          "minLength": 10,
          "description": "One or two sentences: what it is and why a traveller would go. Facts only, no prices."
        },
        "kind": {
          "enum": [
            "town",
            "sight",
            "nature",
            "trail",
            "museum",
            "event",
            "ski_resort",
            "food_area",
            "stay"
          ],
          "type": "string",
          "description": "What it is. stay is a hotel worth the trip in itself."
        },
        "name": {
          "type": "string",
          "maxLength": 120,
          "minLength": 2,
          "description": "The place's proper name, e.g. \"Lake Bohinj\"."
        },
        "town": {
          "type": "string",
          "maxLength": 80,
          "description": "The nearest town, when the place is not a town itself."
        },
        "country": {
          "type": "string",
          "maxLength": 60,
          "description": "English country name, e.g. \"Slovenia\"."
        },
        "source_url": {
          "type": "string",
          "maxLength": 300,
          "description": "The place's official website, or another current page showing it exists and is open."
        }
      }
    }
    arguments 65 lines
  • list_my_plans unknown never probed

    The signed-in traveller's trip plans in the Meridian Dispatch app: id, title, dates, countries, number of days planned (the app makes days as the traveller fills them, so it can be fewer than the dates span), seq (the plan's version), whether the app has taken in the latest version, and when it last changed. Needs the traveller to sign in to Meridian Dispatch the first time (the client is asked to authorise). Use get_plan for one plan's days and places.

    mcp-tool

    {
      "type": "object",
      "properties": {}
    }
    arguments 4 lines
  • suggest_for_my_day unknown never probed

    What to do on one day of the signed-in traveller's plan: places near that day's hotel (or its town, when the hotel cannot be placed), ranked for THIS traveller the way the app's For You list ranks them: their travel preferences, how full the day already is for their pace, what the rest of the trip already holds (no fourth museum in a row), what they have planned on past trips, and how famous and how well travellers rate each place. Each place comes with why (the reason it is on the list for them, in the app's words), must_see, distance_miles from the anchor, its description, and its Meridian Dispatch page when it has one. Places already on the plan are left out. The ranking draws only on the Meridian Dispatch guides, so a thin town gives a short list; notes says what the ranking could not know (it cannot see the traveller's photo journal, so a place they have been can still appear). Pass day as the day number from the plan's first date (1 is the first day), or date. Use get_plan first if you need the plan id or the day. Needs sign-in.

    mcp-tool

    {
      "type": "object",
      "required": [
        "plan_id"
      ],
      "properties": {
        "day": {
          "type": "integer",
          "maximum": 120,
          "minimum": 1,
          "description": "Which day, counted from the plan's first date: 1 is the first day. Default 1."
        },
        "date": {
          "type": "string",
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "description": "Or the day's date, YYYY-MM-DD, instead of day."
        },
        "limit": {
          "type": "integer",
          "maximum": 20,
          "minimum": 1,
          "description": "How many places, 10 by default."
        },
        "plan_id": {
          "type": "string",
          "description": "The plan id from list_my_plans."
        }
      }
    }
    arguments 29 lines
  • edit_plan unknown never probed

    Change a plan with a list of ops (see the ops schema), applied in order, all or nothing; days are named by date (YYYY-MM-DD), set_start_date moves every day and booking, and close_day takes out a day between the first and last and moves every later day one date earlier (bookings keep their dates). base_seq is required: the seq from get_plan, so a plan changed elsewhere since you read it is refused rather than overwritten; on a conflict, read it again and redo the edit. Stop and booking ids come from get_plan. Prefer places from get_destination or get_place (meridian_url), so the map can place them; title each place by its proper name with what the traveller does there in visitNote, give every other real place its lat and lng, and every place a time, in the order of the day, so the app can draw the travel between them (a place without a time is timed after the one before it). Ask the traveller before removing anything. Needs sign-in.

    mcp-tool

    {
      "type": "object",
      "required": [
        "plan_id",
        "base_seq",
        "ops"
      ],
      "properties": {
        "ops": {
          "type": "array",
          "items": {
            "anyOf": [
              {
                "type": "object",
                "required": [
                  "op",
                  "title"
                ],
                "properties": {
                  "op": {
                    "const": "set_title"
                  },
                  "title": {
                    "type": "string",
                    "maxLength": 200,
                    "minLength": 1
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "startDate"
                ],
                "properties": {
                  "op": {
                    "const": "set_start_date"
                  },
                  "startDate": {
                    "type": "string",
                    "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "date"
                ],
                "properties": {
                  "op": {
                    "const": "add_day"
                  },
                  "date": {
                    "type": "string",
                    "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "date"
                ],
                "properties": {
                  "op": {
                    "const": "remove_day"
                  },
                  "date": {
                    "type": "string",
                    "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                  },
                  "force": {
                    "type": "boolean",
                    "description": "Required when the day holds stops or a booking starting that day: removes the day and its stops (bookings are kept). Without it such a day is refused, naming what it holds. Ask the traveller first."
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "date"
                ],
                "properties": {
                  "op": {
                    "const": "close_day"
                  },
                  "date": {
                    "type": "string",
                    "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                  },
                  "force": {
                    "type": "boolean",
                    "description": "Required when the day holds stops: they are removed (its notes move to the day before). Ask the traveller first."
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "date"
                ],
                "properties": {
                  "op": {
                    "const": "set_day"
                  },
                  "date": {
                    "type": "string",
                    "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                  },
                  "town": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "summary": {
                    "type": [
                      "string",
                      "null"
                    ]
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "date",
                  "stop"
                ],
                "properties": {
                  "op": {
                    "const": "add_stop"
                  },
                  "date": {
                    "type": "string",
                    "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                  },
                  "stop": {
                    "type": "object",
                    "properties": {
                      "lat": {
                        "type": "number",
                        "maximum": 90,
                        "minimum": -90,
                        "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town."
                      },
                      "lng": {
                        "type": "number",
                        "maximum": 180,
                        "minimum": -180,
                        "description": "Longitude, with lat."
                      },
                      "note": {
                        "type": "string",
                        "maxLength": 2000,
                        "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote."
                      },
                      "time": {
                        "type": "string",
                        "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
                        "description": "HH:mm, 24-hour."
                      },
                      "town": {
                        "type": "string",
                        "maxLength": 100
                      },
                      "type": {
                        "enum": [
                          "activity",
                          "restaurant",
                          "freeform"
                        ],
                        "type": "string",
                        "description": "freeform for a transfer or a note."
                      },
                      "prose": {
                        "type": "string",
                        "maxLength": 2000
                      },
                      "title": {
                        "type": "string",
                        "maxLength": 200
                      },
                      "booked": {
                        "type": "boolean",
                        "description": "For a restaurant, a tour or a ticketed sight: true once the traveller holds the table or ticket, false while it still needs booking (it then shows in the app's Still to book, with BOOK opening ticketsURL). Leave it out for a place that needs nothing."
                      },
                      "minutes": {
                        "type": "integer",
                        "maximum": 1440,
                        "minimum": 1
                      },
                      "category": {
                        "type": "string",
                        "maxLength": 60
                      },
                      "visitNote": {
                        "type": "string",
                        "maxLength": 240,
                        "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\")."
                      },
                      "ticketsURL": {
                        "type": "string",
                        "format": "uri",
                        "description": "https only. The official page to book this stop: a sight's own ticket shop, or for a restaurant its reservation page (its own site, or the booking service it uses: OpenTable, Resy, SevenRooms, TheFork, Tock). Still to book's BOOK opens it; without one the row shows no BOOK. Never a reseller or a search page."
                      },
                      "meridian_url": {
                        "type": "string",
                        "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map."
                      }
                    }
                  },
                  "position": {
                    "type": "integer",
                    "minimum": 0
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "id",
                  "fields"
                ],
                "properties": {
                  "id": {
                    "type": "string",
                    "description": "A stop or booking id from get_plan."
                  },
                  "op": {
                    "const": "update_stop"
                  },
                  "fields": {
                    "type": "object",
                    "properties": {
                      "lat": {
                        "type": "number",
                        "maximum": 90,
                        "minimum": -90,
                        "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town."
                      },
                      "lng": {
                        "type": "number",
                        "maximum": 180,
                        "minimum": -180,
                        "description": "Longitude, with lat."
                      },
                      "note": {
                        "type": "string",
                        "maxLength": 2000,
                        "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote."
                      },
                      "time": {
                        "type": "string",
                        "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
                        "description": "HH:mm, 24-hour."
                      },
                      "town": {
                        "type": "string",
                        "maxLength": 100
                      },
                      "type": {
                        "enum": [
                          "activity",
                          "restaurant",
                          "freeform"
                        ],
                        "type": "string",
                        "description": "freeform for a transfer or a note."
                      },
                      "prose": {
                        "type": "string",
                        "maxLength": 2000
                      },
                      "title": {
                        "type": "string",
                        "maxLength": 200
                      },
                      "booked": {
                        "type": "boolean",
                        "description": "For a restaurant, a tour or a ticketed sight: true once the traveller holds the table or ticket, false while it still needs booking (it then shows in the app's Still to book, with BOOK opening ticketsURL). Leave it out for a place that needs nothing."
                      },
                      "minutes": {
                        "type": "integer",
                        "maximum": 1440,
                        "minimum": 1
                      },
                      "category": {
                        "type": "string",
                        "maxLength": 60
                      },
                      "visitNote": {
                        "type": "string",
                        "maxLength": 240,
                        "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\")."
                      },
                      "ticketsURL": {
                        "type": "string",
                        "format": "uri",
                        "description": "https only. The official page to book this stop: a sight's own ticket shop, or for a restaurant its reservation page (its own site, or the booking service it uses: OpenTable, Resy, SevenRooms, TheFork, Tock). Still to book's BOOK opens it; without one the row shows no BOOK. Never a reseller or a search page."
                      },
                      "meridian_url": {
                        "type": "string",
                        "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map."
                      }
                    },
                    "description": "null on a field clears it."
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "id",
                  "date"
                ],
                "properties": {
                  "id": {
                    "type": "string",
                    "description": "A stop or booking id from get_plan."
                  },
                  "op": {
                    "const": "move_stop"
                  },
                  "date": {
                    "type": "string",
                    "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                  },
                  "position": {
                    "type": "integer",
                    "minimum": 0
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "id"
                ],
                "properties": {
                  "id": {
                    "type": "string",
                    "description": "A stop or booking id from get_plan."
                  },
                  "op": {
                    "const": "remove_stop"
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "booking"
                ],
                "properties": {
                  "op": {
                    "const": "add_booking"
                  },
                  "booking": {
                    "type": "object",
                    "required": [
                      "type",
                      "title"
                    ],
                    "properties": {
                      "city": {
                        "type": "string",
                        "maxLength": 100
                      },
                      "type": {
                        "enum": [
                          "hotel",
                          "flight",
                          "train",
                          "carRental",
                          "restaurant",
                          "activity",
                          "other"
                        ],
                        "type": "string"
                      },
                      "title": {
                        "type": "string",
                        "maxLength": 200
                      },
                      "booked": {
                        "type": "boolean"
                      },
                      "details": {
                        "type": "object",
                        "properties": {
                          "seat": {
                            "type": "string"
                          },
                          "cabin": {
                            "type": "string"
                          },
                          "nights": {
                            "type": "string"
                          },
                          "address": {
                            "type": "string"
                          },
                          "airline": {
                            "type": "string"
                          },
                          "company": {
                            "type": "string"
                          },
                          "website": {
                            "type": "string",
                            "format": "uri"
                          },
                          "carriage": {
                            "type": "string"
                          },
                          "operator": {
                            "type": "string"
                          },
                          "roomType": {
                            "type": "string"
                          },
                          "partySize": {
                            "type": "string"
                          },
                          "originCity": {
                            "type": "string"
                          },
                          "originCode": {
                            "type": "string",
                            "pattern": "^[A-Z]{3}$"
                          },
                          "returnSeat": {
                            "type": "string"
                          },
                          "trainNumber": {
                            "type": "string"
                          },
                          "flightNumber": {
                            "type": "string",
                            "description": "e.g. OS36"
                          },
                          "vehicleClass": {
                            "type": "string"
                          },
                          "originAirport": {
                            "type": "string"
                          },
                          "originStation": {
                            "type": "string"
                          },
                          "returnAirline": {
                            "type": "string"
                          },
                          "pickupLocation": {
                            "type": "string"
                          },
                          "arrivalTerminal": {
                            "type": "string"
                          },
                          "destinationCity": {
                            "type": "string"
                          },
                          "destinationCode": {
                            "type": "string",
                            "pattern": "^[A-Z]{3}$"
                          },
                          "dropoffLocation": {
                            "type": "string"
                          },
                          "returnOriginCode": {
                            "type": "string",
                            "pattern": "^[A-Z]{3}$"
                          },
                          "departureTerminal": {
                            "type": "string"
                          },
                          "returnArrivalDate": {
                            "type": "string",
                            "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                          },
                          "returnArrivalTime": {
                            "type": "string",
                            "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                          },
                          "destinationAirport": {
                            "type": "string"
                          },
                          "destinationStation": {
                            "type": "string"
                          },
                          "returnFlightNumber": {
                            "type": "string"
                          },
                          "outboundArrivalDate": {
                            "type": "string",
                            "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                          },
                          "outboundArrivalTime": {
                            "type": "string",
                            "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                          },
                          "returnDepartureDate": {
                            "type": "string",
                            "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                          },
                          "returnDepartureTime": {
                            "type": "string",
                            "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                          },
                          "outboundDepartureDate": {
                            "type": "string",
                            "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                          },
                          "outboundDepartureTime": {
                            "type": "string",
                            "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                          },
                          "returnDestinationCode": {
                            "type": "string",
                            "pattern": "^[A-Z]{3}$"
                          }
                        },
                        "description": "The booking's particulars, in these keys only (any other is dropped). Fill every one you know: the app draws the booking from them, not from the title. A flight: airline, flightNumber, originCode and destinationCode (IATA), originAirport and destinationAirport (the airports' names), originCity and destinationCity, departureTerminal, arrivalTerminal, cabin, seat; startDate/startTime is the departure and endDate/endTime the arrival, local times. Prefer one booking per leg; a round trip already held as one booking carries returnAirline, returnFlightNumber, returnOriginCode, returnDestinationCode, returnDepartureDate, returnDepartureTime, returnArrivalDate, returnArrivalTime, returnSeat, with outboundArrivalDate/Time for the first leg. A hotel: address, website, roomType, nights (check-in and check-out times go in startTime and endTime). A restaurant: address, website, partySize (its stop's ticketsURL is the reservation page). A tour or activity: company (the operator), address (the meeting point), website. A train: operator, trainNumber, carriage, seat, originStation, destinationStation, originCity, destinationCity. A car rental: company, vehicleClass, pickupLocation, dropoffLocation. Never the name on the booking.",
                        "additionalProperties": {
                          "type": "string"
                        }
                      },
                      "endDate": {
                        "type": "string",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                      },
                      "endTime": {
                        "type": "string",
                        "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                      },
                      "subtitle": {
                        "type": "string",
                        "maxLength": 200
                      },
                      "startDate": {
                        "type": "string",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                      },
                      "startTime": {
                        "type": "string",
                        "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                      },
                      "countryCode": {
                        "type": "string",
                        "pattern": "^[A-Za-z]{2}$"
                      }
                    }
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "id",
                  "fields"
                ],
                "properties": {
                  "id": {
                    "type": "string",
                    "description": "A stop or booking id from get_plan."
                  },
                  "op": {
                    "const": "update_booking"
                  },
                  "fields": {
                    "type": "object",
                    "properties": {
                      "city": {
                        "type": "string",
                        "maxLength": 100
                      },
                      "type": {
                        "enum": [
                          "hotel",
                          "flight",
                          "train",
                          "carRental",
                          "restaurant",
                          "activity",
                          "other"
                        ],
                        "type": "string"
                      },
                      "title": {
                        "type": "string",
                        "maxLength": 200
                      },
                      "booked": {
                        "type": "boolean"
                      },
                      "details": {
                        "type": "object",
                        "properties": {
                          "seat": {
                            "type": "string"
                          },
                          "cabin": {
                            "type": "string"
                          },
                          "nights": {
                            "type": "string"
                          },
                          "address": {
                            "type": "string"
                          },
                          "airline": {
                            "type": "string"
                          },
                          "company": {
                            "type": "string"
                          },
                          "website": {
                            "type": "string",
                            "format": "uri"
                          },
                          "carriage": {
                            "type": "string"
                          },
                          "operator": {
                            "type": "string"
                          },
                          "roomType": {
                            "type": "string"
                          },
                          "partySize": {
                            "type": "string"
                          },
                          "originCity": {
                            "type": "string"
                          },
                          "originCode": {
                            "type": "string",
                            "pattern": "^[A-Z]{3}$"
                          },
                          "returnSeat": {
                            "type": "string"
                          },
                          "trainNumber": {
                            "type": "string"
                          },
                          "flightNumber": {
                            "type": "string",
                            "description": "e.g. OS36"
                          },
                          "vehicleClass": {
                            "type": "string"
                          },
                          "originAirport": {
                            "type": "string"
                          },
                          "originStation": {
                            "type": "string"
                          },
                          "returnAirline": {
                            "type": "string"
                          },
                          "pickupLocation": {
                            "type": "string"
                          },
                          "arrivalTerminal": {
                            "type": "string"
                          },
                          "destinationCity": {
                            "type": "string"
                          },
                          "destinationCode": {
                            "type": "string",
                            "pattern": "^[A-Z]{3}$"
                          },
                          "dropoffLocation": {
                            "type": "string"
                          },
                          "returnOriginCode": {
                            "type": "string",
                            "pattern": "^[A-Z]{3}$"
                          },
                          "departureTerminal": {
                            "type": "string"
                          },
                          "returnArrivalDate": {
                            "type": "string",
                            "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                          },
                          "returnArrivalTime": {
                            "type": "string",
                            "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                          },
                          "destinationAirport": {
                            "type": "string"
                          },
                          "destinationStation": {
                            "type": "string"
                          },
                          "returnFlightNumber": {
                            "type": "string"
                          },
                          "outboundArrivalDate": {
                            "type": "string",
                            "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                          },
                          "outboundArrivalTime": {
                            "type": "string",
                            "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                          },
                          "returnDepartureDate": {
                            "type": "string",
                            "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                          },
                          "returnDepartureTime": {
                            "type": "string",
                            "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                          },
                          "outboundDepartureDate": {
                            "type": "string",
                            "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                          },
                          "outboundDepartureTime": {
                            "type": "string",
                            "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                          },
                          "returnDestinationCode": {
                            "type": "string",
                            "pattern": "^[A-Z]{3}$"
                          }
                        },
                        "description": "The booking's particulars, in these keys only (any other is dropped). Fill every one you know: the app draws the booking from them, not from the title. A flight: airline, flightNumber, originCode and destinationCode (IATA), originAirport and destinationAirport (the airports' names), originCity and destinationCity, departureTerminal, arrivalTerminal, cabin, seat; startDate/startTime is the departure and endDate/endTime the arrival, local times. Prefer one booking per leg; a round trip already held as one booking carries returnAirline, returnFlightNumber, returnOriginCode, returnDestinationCode, returnDepartureDate, returnDepartureTime, returnArrivalDate, returnArrivalTime, returnSeat, with outboundArrivalDate/Time for the first leg. A hotel: address, website, roomType, nights (check-in and check-out times go in startTime and endTime). A restaurant: address, website, partySize (its stop's ticketsURL is the reservation page). A tour or activity: company (the operator), address (the meeting point), website. A train: operator, trainNumber, carriage, seat, originStation, destinationStation, originCity, destinationCity. A car rental: company, vehicleClass, pickupLocation, dropoffLocation. Never the name on the booking.",
                        "additionalProperties": {
                          "type": "string"
                        }
                      },
                      "endDate": {
                        "type": "string",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                      },
                      "endTime": {
                        "type": "string",
                        "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                      },
                      "subtitle": {
                        "type": "string",
                        "maxLength": 200
                      },
                      "startDate": {
                        "type": "string",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                      },
                      "startTime": {
                        "type": "string",
                        "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$"
                      },
                      "countryCode": {
                        "type": "string",
                        "pattern": "^[A-Za-z]{2}$"
                      }
                    }
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "object",
                "required": [
                  "op",
                  "id"
                ],
                "properties": {
                  "id": {
                    "type": "string",
                    "description": "A stop or booking id from get_plan."
                  },
                  "op": {
                    "const": "remove_booking"
                  }
                },
                "additionalProperties": false
              }
            ]
          },
          "maxItems": 100,
          "minItems": 1
        },
        "plan_id": {
          "type": "string"
        },
        "verbose": {
          "type": "boolean",
          "description": "Return the whole plan. By default the reply shows only the days and bookings the edit touched."
        },
        "base_seq": {
          "type": "integer",
          "description": "The seq from get_plan or list_my_plans. Required."
        }
      }
    }
    arguments 823 lines
  • get_travel_preferences unknown never probed

    The signed-in traveller's travel preferences, as set in the Meridian Dispatch app (How you like to travel): how much they like each kind of travel (coast, old towns, ancient sites, nature, scenic drives, big cities, hiking, museums, food, nightlife, snow, wellness: love, like, sometimes or not for me), the stays they like, their hotel level (budget, mid-range, luxury, ultra luxury: a level in words, never a price) and where their hotels sit (old town, beach, countryside...), their pace (one base, a few bases, always moving), how far a trip goes (stay put, a region, cover ground) and how they get around (drive, trains, a mix), the shape of their days (packed or unhurried, early or late starts, evenings), how they fly (direct, connecting, stopovers) and in which cabin, the airport they fly from (with its IATA code, the other nearby airports they use, and the city code such as NYC or LON when any airport in that city will do), whether they choose main cities or go deep into a country, whether they want new places or old favourites, and the countries they have been to (ISO codes). Worked out in the app from what they actually did, or set by them. Use it to pick bases and hotels at their level, size a day to their pace, route a trip the way they travel, start and end the flights at their home airport, and tell new countries from ones they know. Needs sign-in.

    mcp-tool

    {
      "type": "object",
      "properties": {}
    }
    arguments 4 lines
  • get_place reads unknown 41d ago

    Read the Meridian Dispatch field record for one place: a sight, museum, beach or park, a trail or scenic drive, an event, a ski resort, or an airport. Returns the best time to go, how long it takes, effort, season, access, how to get there and what goes wrong, plus the best months, practical answers, a photo, the town guide link, reviews by travellers who went when there are any (traveller_reviews) and a citation; an event adds its dates and schedule, a trail its route facts, an airport (airport) how to get from the terminal to each town by bus, taxi or ride-hailing app with the road distance, the arrival steps, security rules, food before and after security, airlines and the airports they fly to, what to do on a layover by time available, and what is not yet confirmed. Use it once you know the place. For a whole country or town use get_destination; for a dispatch use get_dispatch; to find a place you cannot name exactly use search_guides; for what else is close use list_nearby. Give url, name or (for an airport) iata, at least one. A place mentioned on a town guide with no page of its own returns its short write-up and that guide. A URL of a town, country or dispatch page returns that guide instead. Read-only. No match returns an error message.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "url": {
          "type": "string",
          "description": "The place's meridiandispatch.com page URL, from a search_guides or get_destination result. Takes priority over name."
        },
        "iata": {
          "type": "string",
          "description": "An airport's three-letter IATA code, e.g. \"MLA\" for Malta International Airport. Returns that airport's page: getting into town, airlines, security, food and layovers."
        },
        "name": {
          "type": "string",
          "description": "The place's name, e.g. \"Kotor Old Town\" or \"Grunas Waterfall\". Exact names match first, then names that contain it. A bare three-letter airport code (\"MLA\") is read as iata."
        },
        "town": {
          "type": "string",
          "description": "The town the place is in or visited from, e.g. \"Kotor\", to narrow a name shared by several places."
        },
        "country": {
          "type": "string",
          "description": "The place's country, by English name, to narrow a name shared by several places."
        }
      }
    }
    arguments 25 lines
  • list_best_places unknown never probed

    List Meridian Dispatch's ranked World's Best places: the 20 best in the world or the 10 best in one country, overall or within one category. Use it for "top things to do in X" or "best beaches in X". For one town's highlights use get_destination; for places near a point use list_nearby; for any other search use search_guides. Returns the list's title, the places in rank order (rank, name, where, a one-line summary, the place's own guide URL where one exists, and a coordinate), the other categories available for that scope, and a citation. Read-only. A country or category with no list returns an error that names the ones that exist.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "country": {
          "type": "string",
          "description": "The country to rank, by English name, e.g. \"Italy\". Omit for the world list."
        },
        "category": {
          "type": "string",
          "description": "One kind of place: landmarks, museums, towns, wilderness, hiking trails, scenic drives, parks, viewpoints, beaches, shopping, wildlife, wellness or ski resorts. Singular and plural both work. Omit for the overall list."
        }
      }
    }
    arguments 13 lines
  • create_plan unknown never probed

    Make a new plan in the traveller's Meridian Dispatch app: a title, a first day and a number of days, optionally with ops to fill it (the same ops as edit_plan). It appears on the website at once and in the app on its next sync. A free account holds one plan; members have as many as they like. Read get_travel_preferences before filling it, so the hotels, pace and routing fit how this traveller travels. Needs sign-in.

    mcp-tool

    {
      "type": "object",
      "required": [
        "title",
        "start_date",
        "days"
      ],
      "properties": {
        "ops": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "op"
            ],
            "properties": {
              "op": {
                "type": "string"
              }
            }
          },
          "maxItems": 100,
          "description": "Optional: the same ops as edit_plan, applied at once."
        },
        "days": {
          "type": "integer",
          "maximum": 120,
          "minimum": 1,
          "description": "How many days."
        },
        "title": {
          "type": "string",
          "maxLength": 200,
          "minLength": 1
        },
        "start_date": {
          "type": "string",
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "description": "The first day, YYYY-MM-DD."
        },
        "country_codes": {
          "type": "array",
          "items": {
            "type": "string",
            "pattern": "^[A-Za-z]{2}$"
          },
          "description": "ISO alpha-2 codes, the main country first."
        }
      }
    }
    arguments 50 lines
  • delete_plan unknown never probed

    Delete a plan from the traveller's account; the app removes it on its next sync. Only when the traveller has asked for it. Needs sign-in.

    mcp-tool

    {
      "type": "object",
      "required": [
        "plan_id"
      ],
      "properties": {
        "plan_id": {
          "type": "string"
        }
      }
    }
    arguments 11 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id e7454ff8a1b9af1f.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/e7454ff8a1b9af1f/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/e7454ff8a1b9af1f/badge.svg)](https://brick.blue/agent/e7454ff8a1b9af1f?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.