Skip to main content
Glama

Named-place route

from_to
Read-onlyIdempotent

Find the shortest walking, cycling, or driving route between two places. Resolves place names or coordinates and returns distance, duration, and maps.

Instructions

Shortest-path walk, cycle, or drive between two places.

from_to is route() with LocationRef ends and a walk default; route is
the canonical routing tool and is growing the same from/to ends, so
prefer route(from=..., to=...) once it takes them.

Pass each of from/to as a free-text place name, a {"lat", "lon"} dict,
or a GERS id — mixed freely. Do not call geocode(), resolve_place(), or
geocode_batch() first. Plain names resolve in parallel exactly as
before; coordinates pass through untouched. Builds one street graph and
returns distance, duration, export maps/gpx/text, and a "from"/"to"
block carrying whatever the input resolved to (name/id when it was a
name or GERS id, lat/lon always).

A comma qualifies: "Alamo Square, SF" searches inside SF only.

If a name matches several equally-ranked places, returns
{"error": "ambiguous_place", "candidates": [...]} instead of picking
a city. If the two ends resolve a city apart, returns
{"error": "too_far"} with the resolved ends and the mode cap rather
than extracting a continent graph. Same per-mode straight-line caps
as a coordinate route (walk ~7.5 km, cycle ~23.5 km, drive ~95.5 km).
An unresolvable name or GERS id returns {"error": "not_found"}; a
malformed from/to (empty string, dict missing lat/lon, wrong type)
returns {"error": "bad_request"} — either way the offending side is
named in "field": "from" | "to". Omit mode to use the stored
preferences mode, else walk.

include_path, include_elevation, prefer, and avoid pass straight through
to route() — see that tool's docstring for what each returns/means
("elevation" climb profile, prefer="flat" grade-avoiding preference and
its honest step-free/accessibility caveats, avoid=["motorway"|"trunk"]
class avoidance and why no toll or ferry option exists). avoid needs
mode="drive": the walk default already excludes those classes.

confirm=true after the user agreed to wait for a first-time street-graph
build (about 5–25 seconds). Pass it only after a needs_confirm reply
and they said yes. A warm or cached graph never needs it.
Omit confirm unless you just asked and they said yes.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
toYes
fromYes
modeNoTravel mode. Default: stored preference, else walk.
avoidNoRoad classes to keep the route off. No toll or ferry option exists: Overture carries no toll attribute, and the graph is road-only. Default: none (no class avoided).
preferNoGrade preference. Default: none (plain-distance routing).
confirmNo
include_pathNo
include_elevationNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Install Server

TDQS

A5/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations mark this read-only and idempotent, and the description agrees without contradicting them. It goes far beyond annotations by detailing exact error shapes ('ambiguous_place', 'too_far', 'not_found', 'bad_request'), per-mode distance caps (7.5/23.5/95.5 km), the maybe-needed 'confirm' delay for first-time graph builds, and pass-through parameter behavior with caveats like 'avoid needs mode="drive"'.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but every paragraph earns its place: input format, error handling, caps, pass-through params, and confirm behavior are each given a compact block. It is front-loaded with the one-sentence summary, and the alternative tool is identified in the second sentence.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a routing tool with 8 parameters and 38% schema coverage, the description covers all invocation-critical details: input resolution, errors, mode defaults, graph-build confirmation, and what outputs are returned. The existing output schema and read-only/idempotent annotations cover the remaining structural expectations.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is only 38%, yet the description thoroughly compensates. It defines the accepted 'from/to' forms (free-text name, {"lat", "lon"} dict, GERS id, mixed), clarifies the default mode ('stored preferences mode, else walk'), and details 'confirm' semantics ('warm or cached graph never needs it'). It even explains the meaning of 'prefer' and 'avoid' via route() semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with 'Shortest-path walk, cycle, or drive between two places,' a specific verb/resource combination that exactly matches the tool name and title. It then explicitly contrasts itself with the sibling 'route' tool: 'from_to is route() with LocationRef ends and a walk default; route is the canonical routing tool.' This makes the tool's unique role unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives direct routing guidance: 'prefer route(from=..., to=...) once it takes them,' telling the agent when to use the sibling instead. It also forbids unnecessary upstream calls ('Do not call geocode(), resolve_place(), or geocode_batch() first') and precisely conditions the confirm flag on user consent ('Pass it only after a needs_confirm reply and they said yes').

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/chuofringer/placeroot'

If you have feedback or need assistance with the MCP directory API, please join our Discord server