Skip to main content
Glama

Open MCP Data Server

An MCP server that gives Claude (or Cursor, or Claude Code) live geospatial data — geocoding, POI search, isochrones, and area density — over open data.

CI PyPI License: MIT

One-line pitch: turn real open data sources into tools any LLM client can call directly. The model orchestrates the calls; this server does the fetching, caching, rate-limiting, and typed validation.


The hook (demo)

Ask Claude Desktop a real geography question and it calls your tools directly:

You (in Claude Desktop):
  "I'm opening a coffee shop. Find all existing cafés within a 15-minute walk
   of Bukit Bintang MRT, and tell me the postcode centroid so I can cross-check
   rent data."

Claude:
  → isochrone(lat=3.1498, lon=101.7149, mode="walk", minutes=15)
  → pois(lat=3.1499, lon=101.7144, radius_m=1200, categories=["cafe"])
  → reverse_geocode(lat=3.1499, lon=101.7144)
  ← cafe list (12 matches), postcode "55100", centroid coords

Claude:
  "There are 12 cafés within a 15-min walk. The postcode centroid is 55100
   (Bukit Bintang). Here's the list, sorted by distance…"

The user never sees an API key or an HTTP call — the model orchestrates the tools. That orchestration, made possible by the server's tool design, is the point of this project.

📸 GIF of a live Claude Desktop session goes here on first publish.


Related MCP server: geocontext

How it works

  ┌─────────────────────┐         MCP (JSON-RPC over stdio)
  │   LLM Client        │  ─────────────────────────────────────┐
  │  (Claude Desktop /  │                                        │
  │   Cursor / Code)    │  ◄──── tool schemas advertised         │
  └─────────────────────┘                                        ▼
                                ┌─────────────────────────────┐
                                │   Open MCP Data Server      │
                                │  (FastMCP Python process)   │
                                │                             │
                                │  @mcp.tool: geocode         │
                                │  @mcp.tool: reverse_geocode │
                                │  @mcp.tool: pois            │
                                │  @mcp.tool: isochrone       │
                                │  @mcp.tool: bbox_summary    │
                                │                             │
                                │  TTLCache + rate limiting   │
                                └──────────────┬──────────────┘
                                               │  https GET/POST
                    ┌──────────────────────────┼──────────────────────┐
                    ▼                          ▼                      ▼
          ┌─────────────────┐    ┌────────────────────┐    ┌─────────────────┐
          │ OSM Nominatim   │    │ Overpass API       │    │ OSRM            │
          │ (geocoding)     │    │ (POIs by amenity)  │    │ (isochrones)    │
          └─────────────────┘    └────────────────────┘    └─────────────────┘

Each tool is a thin async function that fetches upstream data through a shared cache + per-host rate limiter, validates it with Pydantic, and returns a typed result. Inputs are enum-constrained — callers never supply raw Overpass QL.


Tools

Tool

Description

Units

geocode(query)

Forward geocode a place name → coordinate.

lat/lon decimal degrees

reverse_geocode(lat, lon)

Coordinate → human-readable address.

decimal degrees → string

pois(lat, lon, radius_m, categories)

Points of interest within a radius, by category.

metres; counts

isochrone(lat, lon, mode, minutes)

Reachable-area polygon within a time budget.

minutes; polygon [lon,lat]; area m²

bbox_summary(min_lat, min_lon, max_lat, max_lon, categories?)

Counts of key amenities inside a bounding box (density helper).

counts

mode{walk, drive, transit}. categories are enum-constrained (cafe, restaurant, retail, transit, school, attraction, accommodation, bank, healthcare) — all Overpass queries are built server-side.


Quick start

git clone https://github.com/abangbroy/osm-mcp.git
cd osm-mcp
python -m venv .venv && .venv\Scripts\activate     # Windows
# source .venv/bin/activate                        # macOS/Linux
pip install -e ".[dev]"

Run standalone over stdio:

osm-mcp            # or: python -m osm_mcp

Or install the published package directly:

uvx osm-mcp        # or: pip install osm-mcp

Set USER_AGENT (see .env.example) to a descriptive value — Nominatim usage policy requires it.

Claude Desktop config

Add to claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "osm-mcp": {
      "command": "C:\\path\\to\\osm-mcp\\.venv\\Scripts\\osm-mcp.exe",
      "args": []
    }
  }
}

With the published package:

{
  "mcpServers": {
    "osm-mcp": {
      "command": "uvx",
      "args": ["osm-mcp"]
    }
  }
}

Cursor config

Point Cursor at the same command via Settings → MCP → Add Server, using osm-mcp (local venv) or uvx osm-mcp (published).

Tests

pytest --cov=osm_mcp --cov-report=term-missing

Upstream dependencies & rate-limit policy

All upstream APIs are free-tier and shared/public, so they are rate-limited. This server respects their usage terms:

  • TTL cache (CACHE_TTL_SECONDS, default 24h) + per-host rate limiting (RATE_LIMIT_MIN_INTERVAL_SECONDS, default 1s — Nominatim's policy ceiling).

  • A compliant User-Agent header (configurable; required by Nominatim).

  • Bounded retry with exponential backoff for transient errors (429/502/503/ 504, timeouts), honoring Retry-After.

  • transit mode falls back to the OSRM foot profile — OSRM has no transit router. For real transit isochrones, self-host a transit router and point OSRM_BASE_URL at it. This is a documented limitation, stated openly.

  • For production throughput, self-host Nominatim / Overpass / OSRM and set the *_BASE_URL env vars.

Attribution: data © OpenStreetMap contributors (ODbL). Code is MIT; data attribution must accompany any reuse.


Configuration

All settings are environment-driven (see .env.example):

Variable

Default

Purpose

NOMINATIM_BASE_URL

https://nominatim.openstreetmap.org

Geocoding upstream

OVERPASS_BASE_URL

https://overpass-api.de

POI upstream

OSRM_BASE_URL

https://router.project-osrm.org

Routing upstream

USER_AGENT

osm-mcp/0.1.0 (...)

Required by Nominatim policy

CACHE_MAXSIZE / CACHE_TTL_SECONDS

2048 / 86400

TTL cache sizing

RATE_LIMIT_MIN_INTERVAL_SECONDS

1.0

Per-host request spacing

HTTP_TIMEOUT_SECONDS

15.0

Upstream call timeout


Publishing

v1 ships stdio transport. Releases are automated:

  1. PyPI — pushing a v* tag runs publish.yml, which re-runs the tests and lint, verifies the tag matches the version in pyproject.toml, builds, and uploads via Trusted Publishing (OIDC — no API token is stored in the repo).

    git tag v0.1.0 && git push origin v0.1.0

    Requires a one-time pending publisher on PyPI — see the header comment in publish.yml for the exact field values.

  2. Official MCP registry — submit server.json at registry.modelcontextprotocol.io once the PyPI release is live. The server is registered as io.github.abangbroy/osm-mcp; the io.github.<user>/ namespace is what proves GitHub ownership.

SSE-only transports are deprecated since MCP spec 2025-03-26. A Streamable HTTP transport is the planned v2 stretch (no SSE).


Learned in public

This project is a portfolio piece. A few things I learned openly while building it, rather than claiming prior mastery:

  • FastMCP packaging — wiring @mcp.tool decorators to Pydantic-typed signatures and exposing the bounds in the generated JSON schema (so the model sees the limits, not just gets rejected by them).

  • OSRM as an isochrone source — OSRM has no native isochrone endpoint; the radial-sampling + /table approach is a public-methodology workaround.

  • Overpass (poly:) coordinate order — it expects latitude-then-longitude, the opposite of GeoJSON; getting this wrong returns HTTP 400 live.


License

MIT — see LICENSE.

Available Tools

6 tools
bbox_summaryA

Counts of key amenities inside a bounding box (a light density helper).

Units: all coordinates decimal degrees. min is south-west, max is north-east, so min_lat <= max_lat and min_lon <= max_lon are required. categories defaults to a sensible set when omitted. Example: bbox_summary(min_lat=3.14, min_lon=101.70, max_lat=3.16, max_lon=101.72)

ParametersJSON Schema
NameRequiredDescriptionDefault
max_latYesLatitude in decimal degrees [-90, 90].
max_lonYesLongitude in decimal degrees [-180, 180].
min_latYesLatitude in decimal degrees [-90, 90].
min_lonYesLongitude in decimal degrees [-180, 180].
categoriesNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
totalYes
max_latYesLatitude in decimal degrees [-90, 90].
max_lonYesLongitude in decimal degrees [-180, 180].
min_latYesLatitude in decimal degrees [-90, 90].
min_lonYesLongitude in decimal degrees [-180, 180].
by_categoryYes

TDQS

A3.9/5.0
Behavior4/5

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

With no annotations provided, the description carries the behavioral burden. It discloses coordinate units, the SW/NE convention, the required ordering constraints (min_lat <= max_lat, min_lon <= max_lon), and the default behavior of 'categories'. Return shape is not described, but an output schema exists.

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 compact and well-structured: purpose first, then units, coordinate conventions, constraints, default behavior, and a concrete example. Every sentence contributes useful information with no filler.

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

Completeness4/5

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

For a tool with no annotations and an output schema present, the description is nearly complete. It covers units, parameter semantics, defaults, and a calling example. The only notable gap is not explicitly distinguishing this from the related 'pois' sibling.

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

Parameters4/5

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

Schema description coverage is 80%, so baseline is 3. The description adds genuinely useful semantics beyond the schema: all coordinates are decimal degrees, min is south-west, max is north-east, the inequality constraints are required, and categories has a sensible default. The example further clarifies parameter usage.

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

Purpose4/5

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

The description states a clear specific action ('Counts of key amenities inside a bounding box') and identifies itself as a 'light density helper'. This clearly separates it from geocoding and routing siblings, though it does not explicitly contrast with the sibling 'pois' tool.

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

Usage Guidelines3/5

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

The context is reasonably clear: this is for quick amenity counts within a bounding box, and the example reinforces usage. However, there is no explicit guidance on when to choose this over alternatives such as 'pois', and no when-not-to-use conditions are stated.

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

geocodeA

Forward geocode a place name to a WGS84 coordinate (decimal degrees).

Units: latitude/longitude in decimal degrees. Example: geocode(query="KL Sentral") -> GeoPoint(lat=3.1355, lon=101.7044)

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
latYesLatitude in decimal degrees [-90, 90].
lonYesLongitude in decimal degrees [-180, 180].

TDQS

A4.5/5.0
Behavior4/5

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

With no annotations provided, the description carries the behavioral burden. It discloses the coordinate units, the output format via example, and the input/output mapping. It does not mention error handling for ambiguous or non-existent place names, but for a simple stateless lookup the core behavior is transparent.

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 appropriately brief: purpose, units, and a concrete example. Every sentence adds value, and the most important scoping information is front-loaded.

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 tool with one simple parameter and an output schema, the description is complete enough. It explains the input, output coordinate system, and provides an example, which is everything an agent needs to invoke it correctly.

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

Parameters4/5

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

The schema provides only a plain string 'query' with no description, and schema description coverage is 0%. The description compensates by specifying that the query is a place name and gives a concrete example showing expected usage, adding meaning that the schema alone lacks.

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 uses a specific verb and resource: 'Forward geocode a place name to a WGS84 coordinate'. It clearly distinguishes itself from the sibling reverse_geocode by specifying 'forward' and stating the direction from place name to coordinate.

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

Usage Guidelines4/5

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

The description makes clear this is for converting a place name to coordinates, which tells the agent when to use it versus reverse_geocode. It does not explicitly list exclusions or alternative conditions, but the context is strong enough for correct selection.

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

isochroneA

Reachable-area polygon within a travel-time budget.

Units: lat/lon in decimal degrees; minutes in minutes (1-120); polygon ring as [lon, lat] pairs; area_m2 in square metres. Example: isochrone(lat=3.15, lon=101.71, mode="walk", minutes=10)

ParametersJSON Schema
NameRequiredDescriptionDefault
latYesLatitude in decimal degrees [-90, 90].
lonYesLongitude in decimal degrees [-180, 180].
modeYesRouting mode for reachability/isochrone computation.
minutesYesTravel-time budget in minutes (1-120).

Output Schema

ParametersJSON Schema
NameRequiredDescription
latYesLatitude in decimal degrees [-90, 90].
lonYesLongitude in decimal degrees [-180, 180].
modeYes
area_m2Yes
minutesYes
polygonYes

TDQS

A3.8/5.0
Behavior4/5

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does this well by specifying the polygon ring as [lon, lat] pairs, area_m2 units, decimal-degree coordinates, and the 1–120 minute budget range. It does not discuss side effects, but this is a spatial query tool and the core behavior is clearly disclosed.

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 compact and well structured: a one-sentence purpose, a unit/format legend, and a fully worked example. Every sentence earns its place and the most important information appears first.

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

Completeness4/5

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

With an output schema present and a fully documented input schema, the description provides the essential operational facts: coordinate order, units, time-budget bounds, and an example call. It is sufficient for invoking the tool correctly, though it leaves usage-vs-alternative routing to inference.

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

Parameters3/5

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

The input schema already documents all four parameters with 100% coverage, so the baseline is 3. The description adds a meaningful example and confirms units, but it largely restates schema-level details (decimal degrees, minutes 1–120) without adding deeper parameter-specific trade-offs or nuances.

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

Purpose4/5

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

The opening phrase 'Reachable-area polygon within a travel-time budget' is a specific, concrete summary that clearly states the tool's output and resource type. It is conceptually distinct from the geo sister tools, though it does not explicitly name siblings or describe exclusions.

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

Usage Guidelines3/5

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

The description implies usage: use this tool when you need a reachable-area polygon for a given travel-time budget. The example reinforces the intended call shape, but there is no explicit guidance about when to prefer this over geocode, pois, bbox_summary, or reverse_geocode.

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

pingA

Health-check tool.

Returns {"status": "ok"} so any MCP client can confirm reachability.

Example: ping() -> {"status": "ok"}

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.5/5.0
Behavior4/5

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

With no annotations, the description carries the full burden. It discloses the exact output format and the health-check nature of the operation. It does not explicitly state 'no side effects,' but the minimal ping semantics make that reasonably clear.

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 concise and well-structured: a one-line label, a return contract, and an example. There is no filler, and the most important information appears first.

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 zero-argument reachability check with an output schema, this description is fully sufficient. It states what the tool does, what it returns, and how to call it.

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

Parameters4/5

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

The tool has zero parameters and the schema already confirms an empty parameter object, so the schema description coverage is effectively 100%. Per the baseline for zero-parameter tools, a 4 is appropriate; no additional parameter explanation is needed.

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 explicitly identifies it as a health-check tool and gives the exact return payload, so an agent immediately knows its purpose. It is clearly distinguishable from the geospatial sibling tools by being a reachability probe rather than a geocoding/isochrone/POI operation.

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

Usage Guidelines4/5

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

The description states that it is for 'any MCP client to confirm reachability,' which gives a clear usage context. It does not enumerate exclusions, but none are really needed because the tool takes no arguments and the sibling tools serve obviously different purposes.

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

poisA

Points of interest within radius_m of a point, grouped by category.

Units: lat/lon decimal degrees; radius_m metres (max 5000). categories is enum-constrained (no free-text queries). Example: pois(lat=3.15, lon=101.71, radius_m=500, categories=["cafe","transit"])

ParametersJSON Schema
NameRequiredDescriptionDefault
latYesLatitude in decimal degrees [-90, 90].
lonYesLongitude in decimal degrees [-180, 180].
radius_mYesSearch radius in metres (0-5000).
categoriesYesPOI categories to query (enum-constrained, max 9).

Output Schema

ParametersJSON Schema
NameRequiredDescription
latYesLatitude in decimal degrees [-90, 90].
lonYesLongitude in decimal degrees [-180, 180].
poisYes
totalYes
radius_mYes

TDQS

A4.3/5.0
Behavior4/5

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

There are no annotations, so the description carries the burden of behavioral disclosure. It provides useful behavioral details: results are grouped by category, units are decimal degrees and metres, radius is capped at 5000, categories are enum-constrained, and schema documentation states that category values map to fixed OSM tags server-side rather than raw tag expressions. It does not explicitly state read-only behavior or auth needs, but the query nature and constraint details cover the most important operational traits.

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 compact and front-loaded, with the core function stated first, then units and constraints, then a concrete example. Every sentence contributes necessary information, and there is no padding or repetition of schema details.

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?

Given the four-parameter schema and the presence of an output schema, the description is complete enough for correct invocation. It covers the coordinate inputs, radius limit, category constraint, units, and provides an example. There is no missing information required for an agent to construct a valid call.

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

Parameters4/5

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

Schema description coverage is 100%, so the baseline is 3. The description adds semantic value beyond the schema by defining the relationship between parameters: lat/lon define the center point, radius_m defines the search distance, and categories constrain what is returned. The concrete example (lat=3.15, lon=101.71, radius_m=500, categories=["cafe","transit"]) makes parameter usage unambiguous.

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 clearly states the tool's function: returning points of interest within a radius of a coordinate, grouped by category. It is specific about the resource (POIs near a point) and includes an example call that removes any ambiguity. The resource and behavior distinguish it from sibling tools like geocode, reverse_geocode, isochrone, and bbox_summary.

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

Usage Guidelines3/5

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

The description implies when to use the tool: when you need POIs near a lat/lon point within a limited radius, with category filtering. It also states constraints (radius max 5000, categories are enum-constrained, no free-text queries). However, it does not explicitly compare against sibling tools or state when not to use this tool, so an agent must infer the alternatives from the sibling list.

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

reverse_geocodeA

Reverse geocode a coordinate to a human-readable address.

Units: lat/lon in decimal degrees; returns a display-name string. Example: reverse_geocode(lat=3.15, lon=101.71) -> "Bukit Bintang, ..."

ParametersJSON Schema
NameRequiredDescriptionDefault
latYesLatitude in decimal degrees [-90, 90].
lonYesLongitude in decimal degrees [-180, 180].

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4/5.0
Behavior3/5

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

With no annotations, the description must carry the burden. It discloses units, the return type (display-name string), and demonstrates output with an example. However, it does not mention potential failure modes, coverage limitations, or any caveats about accuracy, which are relevant for a reverse geocoding operation.

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 compact and well-structured: a clear one-sentence purpose, a units note, and an illustrative example. Every sentence earns its place, with the example positioned at the end for clarity.

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

Completeness4/5

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

The tool is simple with two fully documented parameters and an output schema available. The description adds units and an example, which is sufficient for an agent to call it correctly. It could be more complete by noting when to prefer it over forward geocoding, but for the tool's complexity it is nearly complete.

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

Parameters4/5

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by reiterating units and providing a worked example that shows exact parameter values and the resulting output pattern. This goes beyond the schema's range descriptions and helps an agent verify correct invocation.

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 states a specific verb and resource: 'Reverse geocode a coordinate to a human-readable address.' This clearly distinguishes it from siblings like geocode (forward geocoding), isochrone, and pois, and the example reinforces the behavior with actual coordinate-to-address mapping.

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

Usage Guidelines3/5

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

The description implies the use case (given lat/lon, get an address) and provides an example, but it does not explicitly mention alternatives or conditions for when to choose this tool over geocode or other siblings. The guidance is implied rather than stated.

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

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 6 tool updatesv0.1.0
    • First observedbbox_summary
    • First observedgeocode
    • First observedisochrone
    • First observedping
    • First observedpois
    • First observedreverse_geocode

TDQS

A4.1/5.0

Scored across 6 tools

Disambiguation5/5

Each tool targets a distinct spatial operation: forward and reverse geocoding are clearly opposed, while isochrone, pois, and bbox_summary are differentiated by query shape (travel budget, radius, bounding box) and return type. There is no real overlap that would cause an agent to select the wrong tool confidently.

Naming Consistency3/5

All names are lowercase snake_case, which helps, but the convention is mixed: geocode/reverse_geocode/ping are verb-like, while isochrone, pois, and bbox_summary are noun-like descriptors. The pattern is readable but not consistently verb_noun.

Tool Count5/5

Six tools is a well-scoped size for an OSM-focused server. Each tool covers a distinct geospatial need without redundancy, and the set does not feel either thin or bloated.

Completeness4/5

The server covers core geospatial workflows: geocoding, reverse geocoding, reachability, POI lookup, and area density summaries. It lacks advanced routing or direct OSM element retrieval, but these are not core to the apparent purpose and can be worked around.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    F
    maintenance
    An experimental MCP server providing spatial context for LLMs by interfacing with French Geoplateforme services. It enables tasks such as geocoding, altitude lookups, and querying administrative, cadastral, or urban planning data.
    11 npm
    4
    MIT
  • A
    license
    A
    quality
    D
    maintenance
    An MCP server that provides AI agents with geospatial analytics by querying Overture Maps data directly from S3, enabling place analytics, building composition, land use classification, and transportation analysis.
    13
    4
    MIT
  • F
    license
    Not graded
    quality
    B
    maintenance
    MCP server that enables LLMs to create and control interactive MapLibre maps by placing markers, drawing paths, and rendering polygons directly in Claude Desktop.
    -