parseapi-mcp 1.9.5 → 1.10.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +28 -0
- package/dist/{chunk-4GV5VTYQ.js → chunk-MO7I4G22.js} +254 -63
- package/dist/http.js +1 -1
- package/dist/registry.js +1 -1
- package/dist/stdio.js +1 -1
- package/package.json +2 -2
package/README.md
CHANGED
|
@@ -279,3 +279,31 @@ A device's emoji font remains the ordinary display.
|
|
|
279
279
|
|
|
280
280
|
These additions are a local release candidate until the matching SDK and
|
|
281
281
|
backend are published. Existing lookup and search contracts are preserved.
|
|
282
|
+
|
|
283
|
+
|
|
284
|
+
## Canonical City operations
|
|
285
|
+
|
|
286
|
+
Classic lookup, search, nearest and named-nearby methods retain their default envelopes and required-field models. Browse and coordinate-nearby use canonical lists: `object`, `data` and nullable `next_cursor` (camelCase properties in Swift/Kotlin). Keep all query options unchanged when continuing a page; no client fetches pages automatically.
|
|
287
|
+
|
|
288
|
+
```json
|
|
289
|
+
{"operation":"city_search","arguments":{"query":"Viena","format":"list","match":"fuzzy","max_distance":1}}
|
|
290
|
+
```
|
|
291
|
+
|
|
292
|
+
Select `format=resource` for one City or `format=list` for a collection. Country inclusion/exclusion sets, timezone sets, inclusive population and meter-elevation bounds, stored-center `bbox` and signed multi-key sorting are available for collections. Unknown numeric facts do not match range filters.
|
|
293
|
+
|
|
294
|
+
Search defaults to prefix matching. Exact and fuzzy matching are explicit; fuzzy accepts maximum edit distance 1 or 2 and returns `match` evidence (`type`, `source`, `value`, `language`, `edit_distance`). Review a fuzzy choice before storing its ID.
|
|
295
|
+
|
|
296
|
+
Reviewed children, ancestors and siblings use canonical lists with partial relationship coverage. Empty data does not prove there are no geographic relatives. Children/siblings accept page controls; ancestors do not. Distance reports great-circle kilometers and miles between stored centers: zero is known zero, null is unknown, and it does not imply travel time or containment.
|
|
297
|
+
|
|
298
|
+
Strict `ambiguity=error` can return HTTP 409 `ambiguous_city` with up to two safe candidate identities. The existing error constructor and unrelated error metadata are preserved; candidates are retained only for that status/code and never contain Deep. GeoJSON is available through HTTP; these typed City list methods do not return GeoJSON.
|
|
299
|
+
|
|
300
|
+
|
|
301
|
+
|
|
302
|
+
|
|
303
|
+
|
|
304
|
+
Coverage by country and available fields is described at https://parseapi.com/city#coverage.
|
|
305
|
+
|
|
306
|
+
`romanized=true` requests reviewed official name forms as `name_romanized` and `romanization_language` (camelCase in Swift/Kotlin). Current reviewed forms cover 20 Japanese whole-city aliases in ja-Latn. Missing or conflicting forms stay null; ASCII folding is not substituted for an official form.
|
|
307
|
+
|
|
308
|
+
|
|
309
|
+
Conditional `If-None-Match` reads and GeoJSON currently use HTTP directly. A matching City ETag returns 304 without a body; ordinary billing and rate limits apply. These JSON client methods do not supply conditional-cache handling.
|
|
@@ -10,7 +10,7 @@ import { ParseAPIError } from "@parseapi/sdk";
|
|
|
10
10
|
function ok(data) {
|
|
11
11
|
return { content: [{ type: "text", text: JSON.stringify(data) }] };
|
|
12
12
|
}
|
|
13
|
-
function errorJson(code, message, docs, requestId, retryAfter) {
|
|
13
|
+
function errorJson(code, message, docs, requestId, retryAfter, candidates) {
|
|
14
14
|
return {
|
|
15
15
|
isError: true,
|
|
16
16
|
content: [{ type: "text", text: JSON.stringify({
|
|
@@ -18,13 +18,14 @@ function errorJson(code, message, docs, requestId, retryAfter) {
|
|
|
18
18
|
message,
|
|
19
19
|
docs,
|
|
20
20
|
request_id: requestId,
|
|
21
|
-
...retryAfter == null ? {} : { retry_after: retryAfter }
|
|
21
|
+
...retryAfter == null ? {} : { retry_after: retryAfter },
|
|
22
|
+
...candidates === void 0 ? {} : { candidates }
|
|
22
23
|
}) }]
|
|
23
24
|
};
|
|
24
25
|
}
|
|
25
26
|
function toErrorResult(err) {
|
|
26
27
|
if (err instanceof ParseAPIError) {
|
|
27
|
-
return errorJson(err.code, err.message, err.docs, err.requestId, err.retryAfter);
|
|
28
|
+
return errorJson(err.code, err.message, err.docs, err.requestId, err.retryAfter, err.status === 409 && err.code === "ambiguous_city" ? err.candidates : void 0);
|
|
28
29
|
}
|
|
29
30
|
const message = err instanceof Error ? err.message : String(err);
|
|
30
31
|
return errorJson("network_error", message, null, null);
|
|
@@ -435,18 +436,14 @@ var agent_catalog_default = {
|
|
|
435
436
|
],
|
|
436
437
|
freshness: {
|
|
437
438
|
mode: "maintained_reference",
|
|
438
|
-
population_period_field: "deep.population_period",
|
|
439
439
|
uniform_refresh_interval_seconds: null,
|
|
440
440
|
actual_age_seconds: null,
|
|
441
|
-
actual_age_status: "not_exposed; population
|
|
441
|
+
actual_age_status: "not_exposed; population observation evidence remains internal"
|
|
442
442
|
},
|
|
443
443
|
uncertainty: {
|
|
444
444
|
name_local: {
|
|
445
445
|
null: "Native name unavailable or identical to the original name before display translation"
|
|
446
446
|
},
|
|
447
|
-
"deep.population_period": {
|
|
448
|
-
null: "Observation period is unknown; never infer it from an import date"
|
|
449
|
-
},
|
|
450
447
|
"deep.water_area": {
|
|
451
448
|
null: "Unknown or inconsistent with the archived total",
|
|
452
449
|
zero: "Reported zero water area"
|
|
@@ -1373,6 +1370,118 @@ var agent_catalog_default = {
|
|
|
1373
1370
|
help: "https://api.parseapi.com/version/2.0.0/emoji/help",
|
|
1374
1371
|
guide: "https://parseapi.com/docs/emoji"
|
|
1375
1372
|
}
|
|
1373
|
+
},
|
|
1374
|
+
city: {
|
|
1375
|
+
operation: "city",
|
|
1376
|
+
endpoint: "GET /city/{name}",
|
|
1377
|
+
endpoints: {
|
|
1378
|
+
resource: "GET /city/id/{id}?format=resource",
|
|
1379
|
+
typeahead: "GET /city?q={query}",
|
|
1380
|
+
browse: "GET /city?browse=true&format=list",
|
|
1381
|
+
spelling: "GET /city/search?q={query}&match={exact|prefix|fuzzy}",
|
|
1382
|
+
nearby_coordinates: "GET /city?lat={lat}&lon={lon}&nearby=true&format=list",
|
|
1383
|
+
children: "GET /city/id/{id}/children",
|
|
1384
|
+
ancestors: "GET /city/id/{id}/ancestors",
|
|
1385
|
+
siblings: "GET /city/id/{id}/siblings",
|
|
1386
|
+
distance: "GET /city/id/{id}/distance/{other}"
|
|
1387
|
+
},
|
|
1388
|
+
determines: [
|
|
1389
|
+
"Covered place identity, native/display names, source place type, geography and timezone where available",
|
|
1390
|
+
"Optional reviewed grain, immediate parent and partial direct place relationships",
|
|
1391
|
+
"Filtered paged City collections; optional paid Deep population, observation date, elevation and area",
|
|
1392
|
+
"Great-circle distance between recorded centers; optional admitted official romanization"
|
|
1393
|
+
],
|
|
1394
|
+
does_not_determine: [
|
|
1395
|
+
"Complete worldwide place or field coverage",
|
|
1396
|
+
"Road distance, routing or travel time",
|
|
1397
|
+
"Official romanization from ASCII folding",
|
|
1398
|
+
"A fresh upstream acquisition on every request",
|
|
1399
|
+
"City execution through /task or /preflight; those admission policies are separate"
|
|
1400
|
+
],
|
|
1401
|
+
required_context: [
|
|
1402
|
+
"Store the own city_ ID from a selected response; do not substitute an upstream identifier or a display name",
|
|
1403
|
+
"Keep country and state codes together; state names are not valid state filters",
|
|
1404
|
+
"Choose grain=municipality when selecting a reviewed whole municipality; type retains source terminology",
|
|
1405
|
+
"Use ambiguity=error for exact selection that requires a caller choice; 409 candidates are bounded public identities",
|
|
1406
|
+
"Keep all filters, limit, language and shape options unchanged when reusing next_cursor"
|
|
1407
|
+
],
|
|
1408
|
+
response: {
|
|
1409
|
+
resource: "format=resource: object=city and the complete ordinary City fields, including own id",
|
|
1410
|
+
collection: "format=list: object=list, data and next_cursor; keep request filters unchanged for continuation",
|
|
1411
|
+
legacy: "Default lookup, typeahead and named-nearby envelopes remain compatible",
|
|
1412
|
+
geojson: "format=geojson: Feature or FeatureCollection; null geometry when coordinates are unavailable"
|
|
1413
|
+
},
|
|
1414
|
+
freshness: {
|
|
1415
|
+
mode: "maintained_source_reference",
|
|
1416
|
+
actual_age_seconds: null,
|
|
1417
|
+
actual_age_status: "Fact observation dates where available; an import date is not an observation date",
|
|
1418
|
+
notes: "Population dates and place boundaries may differ between records. Coverage and limits are documented on the City lander and reference."
|
|
1419
|
+
},
|
|
1420
|
+
uncertainty: {
|
|
1421
|
+
null: "Unsupported, missing or conflicting facts remain null. Null population is not zero. Unknown grain and parent remain null.",
|
|
1422
|
+
coverage: "Partial curated reference. A catalog or index must pass its activation gate; readiness503 is not an empty match.",
|
|
1423
|
+
romanization: "romanized=true returns admitted official aliases only; missing or conflicting aliases return null.",
|
|
1424
|
+
relationships: "coverage=partial; no parent or relation is inferred from a matching name or distance.",
|
|
1425
|
+
distance: "method=great_circle; known zero is preserved, unknown coordinates yield null."
|
|
1426
|
+
},
|
|
1427
|
+
errors: {
|
|
1428
|
+
"400": "Invalid controls or cursor from another query/catalog; restart pagination when the edition changes",
|
|
1429
|
+
"409": "ambiguous_city under ambiguity=error; bounded safe candidates without Deep",
|
|
1430
|
+
"404": "City ID or name is not present in the serving catalog",
|
|
1431
|
+
"503": "Required catalog or admitted spelling index unavailable"
|
|
1432
|
+
},
|
|
1433
|
+
billing: {
|
|
1434
|
+
pooled_requests_per_success: 1,
|
|
1435
|
+
metered: null,
|
|
1436
|
+
deep_extra_units: 0,
|
|
1437
|
+
monetary_quote: null,
|
|
1438
|
+
account_state: "unknown; access, allowance and accepted account terms still apply",
|
|
1439
|
+
conditional_reads: "A 304 response does not waive ordinary request billing"
|
|
1440
|
+
},
|
|
1441
|
+
access: {
|
|
1442
|
+
api_key_required: true,
|
|
1443
|
+
key_types: [
|
|
1444
|
+
"secret",
|
|
1445
|
+
"public",
|
|
1446
|
+
"app"
|
|
1447
|
+
],
|
|
1448
|
+
key_fences: {
|
|
1449
|
+
public: "Allowed browser origin required",
|
|
1450
|
+
app: "Allowed X-App-Id required"
|
|
1451
|
+
},
|
|
1452
|
+
effective_access: null,
|
|
1453
|
+
effective_access_status: "not_checked; key fences, account access and quotas still apply"
|
|
1454
|
+
},
|
|
1455
|
+
retry: {
|
|
1456
|
+
client: "javascript_sdk_and_mcp",
|
|
1457
|
+
default_retries: 2,
|
|
1458
|
+
retry_http_statuses: [
|
|
1459
|
+
429,
|
|
1460
|
+
500,
|
|
1461
|
+
502,
|
|
1462
|
+
503,
|
|
1463
|
+
504
|
|
1464
|
+
],
|
|
1465
|
+
retry_network_errors: true,
|
|
1466
|
+
successful_unknown_retried: false,
|
|
1467
|
+
guidance: "Do not retry a409 automatically. Select a bounded candidate. Correct invalid filters and restart rejected cursors. Respect Retry-After; empty matches are not an outage."
|
|
1468
|
+
},
|
|
1469
|
+
privacy: {
|
|
1470
|
+
public_identity: "Own City IDs only",
|
|
1471
|
+
not_exposed: [
|
|
1472
|
+
"upstream identifiers",
|
|
1473
|
+
"source record keys",
|
|
1474
|
+
"private evidence URLs",
|
|
1475
|
+
"source hashes",
|
|
1476
|
+
"complete dataset exports"
|
|
1477
|
+
]
|
|
1478
|
+
},
|
|
1479
|
+
docs: {
|
|
1480
|
+
help: "https://api.parseapi.com/version/2.0.0/city/help",
|
|
1481
|
+
guide: "https://parseapi.com/docs/city",
|
|
1482
|
+
selection: "https://parseapi.com/docs/city#choose-a-city",
|
|
1483
|
+
continuity: "https://parseapi.com/docs/city#stable-ids"
|
|
1484
|
+
}
|
|
1376
1485
|
}
|
|
1377
1486
|
}
|
|
1378
1487
|
};
|
|
@@ -1548,7 +1657,7 @@ function registerTasks(server, client, transport) {
|
|
|
1548
1657
|
// package.json
|
|
1549
1658
|
var package_default = {
|
|
1550
1659
|
name: "parseapi-mcp",
|
|
1551
|
-
version: "1.
|
|
1660
|
+
version: "1.10.0",
|
|
1552
1661
|
mcpName: "com.parseapi/mcp",
|
|
1553
1662
|
description: "Official ParseAPI MCP server. Look up places, addresses, company numbers, email, phone, weather, dates and more.",
|
|
1554
1663
|
keywords: [
|
|
@@ -1598,7 +1707,7 @@ var package_default = {
|
|
|
1598
1707
|
dependencies: {
|
|
1599
1708
|
"@modelcontextprotocol/node": "^2.0.0",
|
|
1600
1709
|
"@modelcontextprotocol/server": "^2.0.0",
|
|
1601
|
-
"@parseapi/sdk": "^1.
|
|
1710
|
+
"@parseapi/sdk": "^1.11.0",
|
|
1602
1711
|
zod: "^4.0.0"
|
|
1603
1712
|
},
|
|
1604
1713
|
devDependencies: {
|
|
@@ -1620,7 +1729,7 @@ var deep = z4.boolean().optional().describe("Include the nested deep object when
|
|
|
1620
1729
|
var lat = z4.number().min(-90).max(90).describe("Latitude in decimal degrees");
|
|
1621
1730
|
var lon = z4.number().min(-180).max(180).describe("Longitude in decimal degrees");
|
|
1622
1731
|
var iso2 = (what) => z4.string().describe(`ISO 3166-1 alpha-2 ${what}, e.g. US`);
|
|
1623
|
-
var tariffEdition = z4.string().regex(/^[a-f0-9]{64}
|
|
1732
|
+
var tariffEdition = z4.string().max(64).regex(/^(?:[a-f0-9]{64}|ted_[1-9][0-9]{0,19})(?![\s\S])/).refine((value) => value.length === 64 && /^[a-f0-9]{64}$/.test(value) || /^ted_[1-9][0-9]{0,19}(?![\s\S])/.test(value) && (value.length < 24 || value.slice(4) <= "18446744073709551615"), "Use an exact edition ID such as ted_3.").optional().describe("Exact edition returned by Tariff, such as ted_3. Without date, returns undated schedule context.");
|
|
1624
1733
|
var tariffDate = z4.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("YYYY-MM-DD with verified source coverage. Combine with edition only when it covers this date.");
|
|
1625
1734
|
var countryOpt = z4.string().optional().describe("ISO2, ISO3, or a country name. Optional when the lookup is unique.");
|
|
1626
1735
|
var titleWords = {
|
|
@@ -1642,42 +1751,52 @@ var titleWords = {
|
|
|
1642
1751
|
mac: "MAC",
|
|
1643
1752
|
useragent: "User Agent"
|
|
1644
1753
|
};
|
|
1645
|
-
var
|
|
1646
|
-
"
|
|
1647
|
-
"
|
|
1648
|
-
"
|
|
1649
|
-
|
|
1650
|
-
|
|
1651
|
-
|
|
1652
|
-
|
|
1653
|
-
|
|
1654
|
-
|
|
1655
|
-
|
|
1656
|
-
|
|
1657
|
-
|
|
1658
|
-
"
|
|
1659
|
-
"
|
|
1660
|
-
"
|
|
1661
|
-
"
|
|
1662
|
-
"
|
|
1663
|
-
"
|
|
1664
|
-
"
|
|
1665
|
-
"
|
|
1666
|
-
"
|
|
1667
|
-
"
|
|
1668
|
-
"
|
|
1669
|
-
|
|
1670
|
-
|
|
1671
|
-
|
|
1672
|
-
|
|
1673
|
-
|
|
1674
|
-
|
|
1675
|
-
|
|
1676
|
-
|
|
1677
|
-
|
|
1678
|
-
|
|
1679
|
-
|
|
1680
|
-
|
|
1754
|
+
var cityScope = {
|
|
1755
|
+
type: z4.string().min(1).max(60).optional().describe("Stored place type, such as city or ward; filters eligible places without inferring legal status."),
|
|
1756
|
+
grain: z4.enum(["municipality", "subdivision", "locality", "metropolitan_area"]).optional().describe("Reviewed entity grain. Unreviewed places do not match; requires City foundation readiness."),
|
|
1757
|
+
hierarchy: z4.boolean().optional().describe("Include reviewed grain and immediate parent summary, or null when unknown. Requires foundation readiness; otherwise 503.")
|
|
1758
|
+
};
|
|
1759
|
+
var cityAliases = z4.boolean().optional().describe("Match reviewed normalized aliases. Compatibility characters, case and whitespace normalize; native marks and accents remain. No spelling guesses. Requires foundation readiness.");
|
|
1760
|
+
var cityAmbiguity = z4.literal("error").optional().describe("Reject an exact name or nearby anchor matching multiple eligible places with HTTP 409 ambiguous_city and bounded candidate identities. Add filters or choose a stable id from city_search.");
|
|
1761
|
+
var cityRomanized = z4.boolean().optional().describe("Include a reviewed official romanized name and its language. No ASCII-folding fallback; missing or conflicting forms are null.");
|
|
1762
|
+
var cityResourceResponse = { romanized: cityRomanized, format: z4.literal("resource").optional().describe("Opt into object:city without changing classic responses.") };
|
|
1763
|
+
var cityListResponse = { romanized: cityRomanized, format: z4.literal("list").optional().describe("Opt into object:list, data and next_cursor. A null cursor ends the collection; keep the same options on continuation.") };
|
|
1764
|
+
var citySort = (terms) => z4.string().min(1).max(100).regex(new RegExp(`^[+-]?(${terms.join("|")})(,[+-]?(${terms.join("|")}))*$`)).optional().describe("Comma-separated sort terms. Prefix a term with + or - for its direction. Stable ids break ties; unknown values sort last.");
|
|
1765
|
+
var cityCodeList = z4.union([z4.string().min(2).max(149), z4.array(z4.string().regex(/^[a-zA-Z]{2}$/)).min(1).max(50)]).optional();
|
|
1766
|
+
var cityCollectionFilters = {
|
|
1767
|
+
min_population: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional().describe("Minimum stored population. Unknown values do not match; the count may be undated."),
|
|
1768
|
+
max_population: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional().describe("Maximum stored population. Unknown values do not match; the count may be undated."),
|
|
1769
|
+
min_elevation: z4.number().finite().optional().describe("Minimum stored elevation in meters. Unknown values do not match."),
|
|
1770
|
+
max_elevation: z4.number().finite().optional().describe("Maximum stored elevation in meters. Unknown values do not match."),
|
|
1771
|
+
countries: cityCodeList.describe("Include ISO2 countries, as CSV or an array. Intersects with a single country filter; on named nearby, country selects the anchor."),
|
|
1772
|
+
exclude_countries: cityCodeList.describe("Exclude ISO2 countries, as CSV or an array."),
|
|
1773
|
+
timezones: z4.union([z4.string().min(1).max(5049), z4.array(z4.string().min(1).max(100)).min(1).max(50)]).optional().describe("Include exact IANA timezones, as CSV or an array. Intersects with a single timezone filter."),
|
|
1774
|
+
timezone: z4.string().optional().describe("Exact IANA timezone filter, e.g. Europe/Vienna."),
|
|
1775
|
+
bbox: z4.string().optional().describe("Stored-center bounds as west,south,east,north in degrees. West greater than east crosses the date line."),
|
|
1776
|
+
order: z4.enum(["asc", "desc"]).optional().describe("Sort direction; default asc except population defaults to desc. Stable ids break ties."),
|
|
1777
|
+
cursor: z4.string().optional().describe("Opaque continuation cursor. Reuse with exactly the same query, filters, limit, display language, Deep, hierarchy and origin.")
|
|
1778
|
+
};
|
|
1779
|
+
var cityPage = z4.boolean().optional().describe("Opt into next_cursor on search or named-nearby collections. A cursor also enables paging.");
|
|
1780
|
+
function cityCollectionArguments(args) {
|
|
1781
|
+
return {
|
|
1782
|
+
minPopulation: args.min_population,
|
|
1783
|
+
maxPopulation: args.max_population,
|
|
1784
|
+
minElevation: args.min_elevation,
|
|
1785
|
+
maxElevation: args.max_elevation,
|
|
1786
|
+
countries: args.countries,
|
|
1787
|
+
excludeCountries: args.exclude_countries,
|
|
1788
|
+
timezones: args.timezones,
|
|
1789
|
+
timezone: args.timezone,
|
|
1790
|
+
bbox: args.bbox,
|
|
1791
|
+
sort: args.sort,
|
|
1792
|
+
order: args.order,
|
|
1793
|
+
page: args.page || void 0,
|
|
1794
|
+
cursor: args.cursor,
|
|
1795
|
+
format: args.format,
|
|
1796
|
+
romanized: args.romanized || void 0
|
|
1797
|
+
};
|
|
1798
|
+
}
|
|
1799
|
+
var languageTools = /* @__PURE__ */ new Set(["ip", "ip_self", "asn", "company", "npi", "provider", "continent", "continent_countries", "bloc_countries", "country", "country_states", "state", "state_districts", "district", "city", "city_id", "city_search", "city_nearest", "city_nearby", "postal", "postal_nearby", "postal_distance", "currency", "language", "date", "time", "timezone", "measure_units", "emoji", "emoji_search", "emoji_browse", "emoji_parse", "emoji_catalog", "point", "city_list", "city_nearby_coordinates", "city_children", "city_ancestors", "city_siblings"]);
|
|
1681
1800
|
var displayLanguage = z4.string().min(2).max(64).optional().describe("Optional display language, such as fr or zh-Hant. IDs, numeric values and input parsing stay unchanged.");
|
|
1682
1801
|
var emojiFilters = {
|
|
1683
1802
|
limit: z4.number().int().min(1).max(50).optional().describe("Maximum results per page."),
|
|
@@ -1814,7 +1933,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1814
1933
|
);
|
|
1815
1934
|
tool(
|
|
1816
1935
|
"country",
|
|
1817
|
-
"Country names, language codes, currency, calling code and timezones. Deep adds the country reference profile on paid plans, including population
|
|
1936
|
+
"Country names, language codes, currency, calling code and timezones. Deep adds the country reference profile on paid plans, including population, land/water area in km2, coastline in km, mean and extreme elevations in metres, tax and locale conventions. Unknown geography values stay null.",
|
|
1818
1937
|
{ code: iso2("country code"), deep: deep.describe("Include the complete detail bag on a paid plan.") },
|
|
1819
1938
|
(c, a, request) => c.country(a.code, { ...request, deep: a.deep })
|
|
1820
1939
|
);
|
|
@@ -1826,7 +1945,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1826
1945
|
);
|
|
1827
1946
|
tool(
|
|
1828
1947
|
"state",
|
|
1829
|
-
"Look up a state or province by code or name. Deep adds its demographic and tax profile on paid plans
|
|
1948
|
+
"Look up a state or province by code or name. Deep adds its demographic and tax profile on paid plans. Pass country to resolve a colliding code.",
|
|
1830
1949
|
{
|
|
1831
1950
|
code: z4.string().describe("State code or name, e.g. colorado, NC"),
|
|
1832
1951
|
country: countryOpt,
|
|
@@ -1836,17 +1955,17 @@ function buildServer(key, transport, options = {}) {
|
|
|
1836
1955
|
);
|
|
1837
1956
|
tool(
|
|
1838
1957
|
"state_districts",
|
|
1839
|
-
"List the districts, counties or departments of a state. Deep adds population
|
|
1958
|
+
"List the districts, counties or departments of a state. Deep adds population to each result on paid plans.",
|
|
1840
1959
|
{
|
|
1841
1960
|
code: z4.string().describe("State code or name, e.g. NC, colorado"),
|
|
1842
1961
|
country: countryOpt,
|
|
1843
|
-
deep: deep.describe("Include population
|
|
1962
|
+
deep: deep.describe("Include population in each district detail bag on a paid plan.")
|
|
1844
1963
|
},
|
|
1845
1964
|
(c, a, request) => c.state.districts(a.code, { ...request, deep: a.deep, country: a.country })
|
|
1846
1965
|
);
|
|
1847
1966
|
tool(
|
|
1848
1967
|
"district",
|
|
1849
|
-
"Look up a district, county or department by code or name. Deep adds area, population and seat on paid plans. Pass state to resolve a colliding name.
|
|
1968
|
+
"Look up a district, county or department by code or name. Deep adds area, population and seat on paid plans. Pass state to resolve a colliding name. Paid deep property_tax contains annual_median, currency and period: median annual tax payable on owner-occupied homes in the area, adjusted to the final year of that period. It is not a rate or property bill. Unsupported, missing and censored estimates are null.",
|
|
1850
1969
|
{
|
|
1851
1970
|
code: z4.string().describe("District code or name, e.g. 37081, guilford county"),
|
|
1852
1971
|
country: countryOpt,
|
|
@@ -1857,38 +1976,50 @@ function buildServer(key, transport, options = {}) {
|
|
|
1857
1976
|
);
|
|
1858
1977
|
tool(
|
|
1859
1978
|
"city",
|
|
1860
|
-
"Resolve a city name to coordinates, timezone and administrative context. Deep adds demographic and geographic detail on paid plans. Pass country or state for name ties.
|
|
1979
|
+
"Resolve a city name to coordinates, timezone and administrative context. Deep adds demographic and geographic detail on paid plans. Pass country or state for name ties.",
|
|
1861
1980
|
{
|
|
1862
1981
|
name: z4.string().describe("City name, e.g. charlotte"),
|
|
1863
1982
|
country: countryOpt,
|
|
1864
1983
|
state: z4.string().optional().describe("State code to disambiguate, e.g. NC"),
|
|
1984
|
+
...cityScope,
|
|
1985
|
+
...cityResourceResponse,
|
|
1986
|
+
aliases: cityAliases,
|
|
1987
|
+
ambiguity: cityAmbiguity,
|
|
1865
1988
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1866
1989
|
},
|
|
1867
|
-
(c, a, request) => c.city(a.name, { ...request, deep: a.deep, country: a.country, state: a.state })
|
|
1990
|
+
(c, a, request) => c.city(a.name, { ...request, deep: a.deep, country: a.country, state: a.state, type: a.type, grain: a.grain, aliases: a.aliases || void 0, hierarchy: a.hierarchy || void 0, ambiguity: a.ambiguity, format: a.format, romanized: a.romanized || void 0 })
|
|
1868
1991
|
);
|
|
1869
1992
|
tool(
|
|
1870
1993
|
"city_id",
|
|
1871
1994
|
"Resolve a stable city id. Deep adds the city profile on paid plans.",
|
|
1872
|
-
{ id: z4.string().describe("Stable city id, e.g. city_mb8mbqrkz8zb"), deep: deep.describe("Include the complete detail bag on a paid plan.") },
|
|
1873
|
-
(c, a, request) => c.city.id(a.id, { ...request, deep: a.deep })
|
|
1995
|
+
{ id: z4.string().describe("Stable city id, e.g. city_mb8mbqrkz8zb"), ...cityResourceResponse, hierarchy: cityScope.hierarchy, deep: deep.describe("Include the complete detail bag on a paid plan.") },
|
|
1996
|
+
(c, a, request) => c.city.id(a.id, { ...request, deep: a.deep, hierarchy: a.hierarchy || void 0, format: a.format, romanized: a.romanized || void 0 })
|
|
1874
1997
|
);
|
|
1875
1998
|
tool(
|
|
1876
1999
|
"city_search",
|
|
1877
|
-
"Search city names. Deep adds the profile inside each returned city on paid plans.",
|
|
2000
|
+
"Search city names. Explicit match uses the spelling search route; numeric/map/timezone/sort filters apply to default prefix search only. Deep adds the profile inside each returned city on paid plans.",
|
|
1878
2001
|
{
|
|
1879
|
-
query: z4.string().describe("
|
|
2002
|
+
query: z4.string().describe("City name query, e.g. char"),
|
|
2003
|
+
match: z4.enum(["exact", "prefix", "fuzzy"]).optional().describe("Explicit matching mode; default prefix. Fuzzy results carry suggestion evidence."),
|
|
2004
|
+
max_distance: z4.union([z4.literal(1), z4.literal(2)]).optional().describe("Maximum edit distance for fuzzy matching."),
|
|
1880
2005
|
country: countryOpt,
|
|
1881
2006
|
state: z4.string().optional().describe("State code filter"),
|
|
2007
|
+
...cityScope,
|
|
2008
|
+
aliases: cityAliases,
|
|
2009
|
+
...cityCollectionFilters,
|
|
2010
|
+
...cityListResponse,
|
|
2011
|
+
sort: citySort(["relevance", "name", "population", "country", "elevation"]),
|
|
2012
|
+
page: cityPage,
|
|
1882
2013
|
limit: z4.number().int().min(1).max(50).optional().describe("Max results"),
|
|
1883
2014
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1884
2015
|
},
|
|
1885
|
-
(c, a, request) => c.city.search(a.query, { ...request, deep: a.deep, country: a.country, state: a.state, limit: a.limit })
|
|
2016
|
+
(c, a, request) => c.city.search(a.query, { ...request, deep: a.deep, country: a.country, state: a.state, limit: a.limit, match: a.match, maxDistance: a.max_distance, type: a.type, grain: a.grain, aliases: a.aliases || void 0, hierarchy: a.hierarchy || void 0, ...cityCollectionArguments(a) })
|
|
1886
2017
|
);
|
|
1887
2018
|
tool(
|
|
1888
2019
|
"city_nearest",
|
|
1889
|
-
"Find the nearest city with distance. Deep adds the
|
|
1890
|
-
{ lat, lon, deep },
|
|
1891
|
-
(c, a, request) => c.city.nearest(a.lat, a.lon, { ...request, deep: a.deep })
|
|
2020
|
+
"Find the nearest eligible stored city center within 2,000 km, with distance. Country/state/type/grain constrain candidates; this does not determine which municipality contains the point. Deep adds the paid profile and reviewed observation date/basis when known.",
|
|
2021
|
+
{ lat, lon, country: countryOpt, state: z4.string().optional().describe("State code filter"), ...cityScope, ...cityResourceResponse, deep },
|
|
2022
|
+
(c, a, request) => c.city.nearest(a.lat, a.lon, { ...request, deep: a.deep, country: a.country, state: a.state, type: a.type, grain: a.grain, hierarchy: a.hierarchy || void 0, format: a.format, romanized: a.romanized || void 0 })
|
|
1892
2023
|
);
|
|
1893
2024
|
tool(
|
|
1894
2025
|
"city_nearby",
|
|
@@ -1897,6 +2028,13 @@ function buildServer(key, transport, options = {}) {
|
|
|
1897
2028
|
name: z4.string().describe("Anchor city name, e.g. denver"),
|
|
1898
2029
|
country: countryOpt,
|
|
1899
2030
|
state: z4.string().optional().describe("State code to disambiguate the anchor"),
|
|
2031
|
+
...cityScope,
|
|
2032
|
+
aliases: cityAliases,
|
|
2033
|
+
ambiguity: cityAmbiguity,
|
|
2034
|
+
...cityCollectionFilters,
|
|
2035
|
+
...cityListResponse,
|
|
2036
|
+
sort: citySort(["distance", "name", "population", "country", "elevation"]),
|
|
2037
|
+
page: cityPage,
|
|
1900
2038
|
radius: z4.number().positive().optional().describe("Search radius, default 40 km"),
|
|
1901
2039
|
unit: z4.enum(["km", "mi"]).optional().describe("Radius unit, default km"),
|
|
1902
2040
|
limit: z4.number().int().min(1).max(50).optional().describe("Max results, default 10"),
|
|
@@ -1904,17 +2042,70 @@ function buildServer(key, transport, options = {}) {
|
|
|
1904
2042
|
},
|
|
1905
2043
|
(c, a, request) => c.city.nearby(a.name, {
|
|
1906
2044
|
...request,
|
|
2045
|
+
...cityCollectionArguments(a),
|
|
1907
2046
|
deep: a.deep,
|
|
1908
2047
|
country: a.country,
|
|
1909
2048
|
state: a.state,
|
|
2049
|
+
type: a.type,
|
|
2050
|
+
grain: a.grain,
|
|
2051
|
+
aliases: a.aliases || void 0,
|
|
2052
|
+
hierarchy: a.hierarchy || void 0,
|
|
2053
|
+
ambiguity: a.ambiguity,
|
|
1910
2054
|
radius: a.radius,
|
|
1911
2055
|
unit: a.unit,
|
|
1912
2056
|
limit: a.limit
|
|
1913
2057
|
})
|
|
1914
2058
|
);
|
|
2059
|
+
tool(
|
|
2060
|
+
"city_list",
|
|
2061
|
+
"Browse the stored City catalog with filters, stable sorting and opaque cursor paging. Coverage remains curated, not worldwide. Deep adds the paid profile within each record.",
|
|
2062
|
+
{
|
|
2063
|
+
country: countryOpt,
|
|
2064
|
+
state: z4.string().optional().describe("State code filter"),
|
|
2065
|
+
...cityScope,
|
|
2066
|
+
...cityCollectionFilters,
|
|
2067
|
+
...cityListResponse,
|
|
2068
|
+
sort: citySort(["name", "population", "country", "elevation"]),
|
|
2069
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Max results per page"),
|
|
2070
|
+
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
2071
|
+
},
|
|
2072
|
+
(c, a, request) => c.city.list({ ...request, ...cityCollectionArguments(a), country: a.country, state: a.state, type: a.type, grain: a.grain, hierarchy: a.hierarchy || void 0, limit: a.limit, deep: a.deep })
|
|
2073
|
+
);
|
|
2074
|
+
tool(
|
|
2075
|
+
"city_nearby_coordinates",
|
|
2076
|
+
"List stored city centers near arbitrary coordinates, with radius, collection filters and cursor paging. The point and distances do not infer municipality containment. Deep adds the paid profile within each record.",
|
|
2077
|
+
{
|
|
2078
|
+
lat,
|
|
2079
|
+
lon,
|
|
2080
|
+
country: countryOpt,
|
|
2081
|
+
state: z4.string().optional().describe("State code filter for returned neighbors"),
|
|
2082
|
+
...cityScope,
|
|
2083
|
+
...cityCollectionFilters,
|
|
2084
|
+
...cityListResponse,
|
|
2085
|
+
radius: z4.number().positive().optional().describe("Search radius, default 40 km"),
|
|
2086
|
+
unit: z4.enum(["km", "mi"]).optional().describe("Radius unit, default km"),
|
|
2087
|
+
sort: citySort(["distance", "name", "population", "country", "elevation"]),
|
|
2088
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Max results per page"),
|
|
2089
|
+
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
2090
|
+
},
|
|
2091
|
+
(c, a, request) => c.city.nearbyCoordinates(a.lat, a.lon, { ...request, ...cityCollectionArguments(a), country: a.country, state: a.state, type: a.type, grain: a.grain, hierarchy: a.hierarchy || void 0, radius: a.radius, unit: a.unit, limit: a.limit, deep: a.deep })
|
|
2092
|
+
);
|
|
2093
|
+
const cityRelationId = z4.string().regex(/^city_[23456789abcdefghjkmnpqrstuvwxyz]{12}$/).describe("Stable City id selected from a lookup or search.");
|
|
2094
|
+
const cityRelationOptions = {
|
|
2095
|
+
id: cityRelationId,
|
|
2096
|
+
romanized: cityRomanized,
|
|
2097
|
+
hierarchy: cityScope.hierarchy,
|
|
2098
|
+
deep,
|
|
2099
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Maximum records per page."),
|
|
2100
|
+
cursor: cityCollectionFilters.cursor
|
|
2101
|
+
};
|
|
2102
|
+
tool("city_children", "List reviewed immediate children of a City id. Returns a canonical list with coverage:partial. It does not infer missing relationships.", cityRelationOptions, (c, a, request) => c.city.children(a.id, { ...request, romanized: a.romanized || void 0, limit: a.limit, cursor: a.cursor, hierarchy: a.hierarchy || void 0, deep: a.deep }));
|
|
2103
|
+
tool("city_ancestors", "Follow reviewed parents of a City id, immediate parent first. Returns a canonical list with coverage:partial; an empty list does not prove the city has no administrative parent.", { id: cityRelationId, romanized: cityRomanized, hierarchy: cityScope.hierarchy, deep }, (c, a, request) => c.city.ancestors(a.id, { ...request, romanized: a.romanized || void 0, hierarchy: a.hierarchy || void 0, deep: a.deep }));
|
|
2104
|
+
tool("city_siblings", "List reviewed places sharing the selected City id\u2019s immediate parent. Returns a canonical list with parent_id and coverage:partial.", cityRelationOptions, (c, a, request) => c.city.siblings(a.id, { ...request, romanized: a.romanized || void 0, limit: a.limit, cursor: a.cursor, hierarchy: a.hierarchy || void 0, deep: a.deep }));
|
|
2105
|
+
tool("city_distance", "Great-circle kilometers and miles between two stored City centers. Unknown coordinates return null; this is not travel distance or boundary containment.", { from: cityRelationId, to: cityRelationId }, (c, a, request) => c.city.distance(a.from, a.to, request));
|
|
1915
2106
|
tool(
|
|
1916
2107
|
"postal",
|
|
1917
|
-
"Resolve a postal code to its place, coordinates and timezone. Australian core localities lists suburb choices with city, state and state_name. Null or missing means unknown, and [] means no eligible choices in the reviewed reference. A single choice can coexist with city null, so do not infer a city or a user selection. These are geographic choices, not mailing-address verification. Deep adds area, population
|
|
2108
|
+
"Resolve a postal code to its place, coordinates and timezone. Australian core localities lists suburb choices with city, state and state_name. Null or missing means unknown, and [] means no eligible choices in the reviewed reference. A single choice can coexist with city null, so do not infer a city or a user selection. These are geographic choices, not mailing-address verification. Deep adds area, population, tax references, neighbors and metro associations on paid plans. property_tax is a nullable area statistic with annual_median, currency and period: median annual tax payable on owner-occupied homes, adjusted to the final year of the period. It is not a rate or property bill. Unsupported, missing and censored estimates are null. Tax rates are percentages and alternative geographic references, not additive.",
|
|
1918
2109
|
{
|
|
1919
2110
|
code: z4.string().describe("Postal or ZIP code, e.g. SW1A 1AA, 28202"),
|
|
1920
2111
|
country: countryOpt,
|
package/dist/http.js
CHANGED
package/dist/registry.js
CHANGED
package/dist/stdio.js
CHANGED
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "parseapi-mcp",
|
|
3
|
-
"version": "1.
|
|
3
|
+
"version": "1.10.0",
|
|
4
4
|
"mcpName": "com.parseapi/mcp",
|
|
5
5
|
"description": "Official ParseAPI MCP server. Look up places, addresses, company numbers, email, phone, weather, dates and more.",
|
|
6
6
|
"keywords": [
|
|
@@ -50,7 +50,7 @@
|
|
|
50
50
|
"dependencies": {
|
|
51
51
|
"@modelcontextprotocol/node": "^2.0.0",
|
|
52
52
|
"@modelcontextprotocol/server": "^2.0.0",
|
|
53
|
-
"@parseapi/sdk": "^1.
|
|
53
|
+
"@parseapi/sdk": "^1.11.0",
|
|
54
54
|
"zod": "^4.0.0"
|
|
55
55
|
},
|
|
56
56
|
"devDependencies": {
|