@urbankitstudio/mcp-atlas 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leo Yong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,156 @@
+# @urbankitstudio/mcp-atlas
+
+Query 137 verified US county parcel ArcGIS REST endpoints — owner/APN lookup — via MCP.
+
+An [MCP](https://modelcontextprotocol.io) server that gives AI assistants direct access to UrbanKit Studio's atlas of manually verified county parcel GIS services. Ask Claude or Cursor to find the ArcGIS REST endpoint for any covered county, get the exact owner-search query URL, and look up parcel data — without needing to know anything about ArcGIS REST API conventions.
+
+**Coverage:** 128+ counties across 39 US states (v0.4.0 atlas, updated May 2026).
+
+---
+
+## Quick start
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "mcp-atlas": {
+      "command": "npx",
+      "args": ["-y", "@urbankitstudio/mcp-atlas"]
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to `.cursor/mcp.json` in your project root (or `~/.cursor/mcp.json` globally):
+
+```json
+{
+  "mcpServers": {
+    "mcp-atlas": {
+      "command": "npx",
+      "args": ["-y", "@urbankitstudio/mcp-atlas"]
+    }
+  }
+}
+```
+
+### Install globally (optional)
+
+```sh
+npm install -g @urbankitstudio/mcp-atlas
+```
+
+Then use `mcp-atlas` as the command instead of `npx -y @urbankitstudio/mcp-atlas`.
+
+---
+
+## Tools
+
+### `list_counties`
+
+Lists all counties with a verified parcel REST endpoint.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `state` | string | No | Two-letter abbreviation (`IL`) or full name (`Illinois`) |
+
+**Example prompt:** "List all covered counties in Illinois"
+
+**Example output:**
+```
+ST | County               | Slug                     | Coverage
+--------------------------------------------------------------------
+IL | Kane                 | kane-county              | owner+APN
+IL | Cook                 | cook-county              | APN only
+IL | DuPage               | dupage-county            | owner+APN
+...
+```
+
+---
+
+### `find_county`
+
+Fuzzy-matches a county by name or 5-digit FIPS code. Returns endpoint URLs, searchable field names, owner field, sample query, and license info.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `query` | string | Yes | County name (`Kane`), name+state (`Kane IL`), or FIPS (`17089`) |
+
+**Example prompt:** "Find the parcel endpoint for Kane County Illinois"
+
+---
+
+### `get_parcel_endpoint`
+
+Returns the full ArcGIS REST URL, layer index, searchable fields, owner field, and a ready sample `?where=…&f=json` query for a specific county.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `state` | string | Yes | Two-letter abbreviation or full name |
+| `county` | string | Yes | County name (`Kane` or `Kane County`) |
+
+**Example prompt:** "Give me the ArcGIS REST endpoint for Cook County Illinois"
+
+---
+
+### `build_owner_query`
+
+Constructs the exact ArcGIS REST query URL using the county's verified owner/taxpayer field. Uses `UPPER(field) LIKE UPPER('%NAME%')` — case-insensitive partial match.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `state` | string | Yes | Two-letter abbreviation or full name |
+| `county` | string | Yes | County name |
+| `owner_name` | string | Yes | Owner/taxpayer name (partial match) |
+
+**Example prompt:** "Build an ArcGIS query for properties owned by 'Smith' in Kane County IL"
+
+**Example output:**
+```
+County:       Kane, Illinois
+Owner field:  TaxName
+WHERE clause: UPPER(TaxName) LIKE UPPER('%SMITH%')
+
+Query URL:
+https://gistech.countyofkane.org/arcgis/rest/services/KanePINList/MapServer/0/query
+  ?where=UPPER(TaxName)%20LIKE%20UPPER('%25SMITH%25')
+  &outFields=PIN,TaxName,SiteAddress,SiteCity,MailingAddress
+  &returnGeometry=false&f=json&resultRecordCount=25
+```
+
+---
+
+## Example conversation
+
+> **User:** I'm doing due diligence on properties in Kane County, Illinois. Can you find all parcels owned by "Blackstone"?
+
+> **Claude (using mcp-atlas):**
+> 1. Calls `get_parcel_endpoint` → gets the `gistech.countyofkane.org` URL and confirms the owner field is `TaxName`
+> 2. Calls `build_owner_query` with `owner_name=Blackstone` → returns a ready fetch URL
+> 3. Optionally fetches the URL and formats the parcel results
+
+---
+
+## Atlas coverage
+
+The atlas is maintained by [UrbanKit Studio](https://urbankitstudio.com/parcel-atlas). All endpoints are manually verified. Counties with an owner/taxpayer field support full name-based lookups; PIN-only counties support APN/parcel-number queries.
+
+Full coverage map: https://urbankitstudio.com/parcel-atlas
+
+---
+
+## Data
+
+Atlas data is embedded in the package (no network calls at startup). The underlying `@urbankitstudio/atlas` SDK is also published separately for programmatic use.
+
+---
+
+## License
+
+MIT — © Leo Yong / UrbanKit Studio

package/dist/server.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * @urbankitstudio/mcp-atlas
+ *
+ * MCP server exposing UrbanKit Studio's verified county parcel ArcGIS REST atlas.
+ * Runs over stdio — compatible with Claude Desktop, Cursor, and any MCP client.
+ *
+ * Tools:
+ *   list_counties       – list covered counties (optional state filter)
+ *   find_county         – fuzzy-match a county, return endpoints + searchable fields
+ *   get_parcel_endpoint – return the full REST service URL + ready sample query
+ *   build_owner_query   – construct exact ArcGIS REST query for an owner name
+ */
+export {};

package/dist/server.js

@@ -0,0 +1,410 @@
+#!/usr/bin/env node
+/**
+ * @urbankitstudio/mcp-atlas
+ *
+ * MCP server exposing UrbanKit Studio's verified county parcel ArcGIS REST atlas.
+ * Runs over stdio — compatible with Claude Desktop, Cursor, and any MCP client.
+ *
+ * Tools:
+ *   list_counties       – list covered counties (optional state filter)
+ *   find_county         – fuzzy-match a county, return endpoints + searchable fields
+ *   get_parcel_endpoint – return the full REST service URL + ready sample query
+ *   build_owner_query   – construct exact ArcGIS REST query for an owner name
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod/v3";
+import { atlas, atlasIndex, slugify, countySlugFromName, } from "@urbankitstudio/atlas";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function ownerFieldFrom(endpoint) {
+    const f = endpoint.searchFields.find((sf) => /owner|taxpayer|taxname/i.test(sf.name));
+    return f?.name ?? null;
+}
+function buildArcgisOwnerQuery(endpoint, ownerQuery) {
+    const field = ownerFieldFrom(endpoint);
+    if (!field)
+        return "";
+    const where = `UPPER(${field}) LIKE UPPER('%25${encodeURIComponent(ownerQuery)}%25')`;
+    const liveFields = endpoint.searchFields
+        .filter((sf) => sf.searchable)
+        .map((sf) => sf.name)
+        .join(",");
+    return (`${endpoint.url}/query` +
+        `?where=${where}` +
+        `&outFields=${liveFields}` +
+        `&returnGeometry=false` +
+        `&f=json` +
+        `&resultRecordCount=25`);
+}
+function formatCountySummary(c) {
+    const epSummary = c.endpoints.length === 0
+        ? "no REST endpoint mapped"
+        : c.endpoints
+            .map((ep) => {
+            const ownerField = ownerFieldFrom(ep);
+            const searchable = ep.searchFields
+                .filter((sf) => sf.searchable)
+                .map((sf) => `${sf.name} (${sf.label})`)
+                .join(", ");
+            return [
+                `  URL: ${ep.url}`,
+                `  Service: ${ep.serviceType}/layer ${ep.layerIndex}`,
+                `  Status: ${ep.status}`,
+                `  Searchable fields: ${searchable || "none"}`,
+                `  Owner field: ${ownerField ?? "none (PIN-only county)"}`,
+                `  License: ${ep.license}`,
+            ].join("\n");
+        })
+            .join("\n---\n");
+    return [
+        `${c.county}, ${c.stateName} (${c.state})`,
+        `FIPS: ${c.countyFips ?? "n/a"}`,
+        `Endpoints (${c.endpoints.length}):`,
+        epSummary,
+        c.notes ? `Notes: ${c.notes}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+const server = new McpServer({ name: "mcp-atlas", version: "0.1.0" }, {
+    instructions: "UrbanKit Atlas MCP server. Use list_counties to discover coverage, find_county or get_parcel_endpoint to get the ArcGIS REST URL, and build_owner_query to construct a ready-to-fire owner-name lookup URL.",
+});
+// ---------------------------------------------------------------------------
+// Tool: list_counties
+// ---------------------------------------------------------------------------
+server.registerTool("list_counties", {
+    title: "List covered counties",
+    description: "Returns all counties in the UrbanKit Atlas that have a verified ArcGIS REST parcel endpoint. Pass a state abbreviation (e.g. 'IL') or state name (e.g. 'Illinois') to filter by state. Omit state to list all ~137 counties.",
+    inputSchema: {
+        state: z
+            .string()
+            .optional()
+            .describe("Optional: two-letter state abbreviation (e.g. 'IL') or full state name (e.g. 'Illinois')"),
+    },
+}, ({ state }) => {
+    const stateFilter = state?.trim().toLowerCase();
+    const rows = [];
+    for (const stateEntry of atlasIndex.states) {
+        if (!stateEntry.populated)
+            continue;
+        // Filter by state if provided
+        if (stateFilter) {
+            const matchAbbrev = stateEntry.abbrev.toLowerCase() === stateFilter;
+            const matchName = stateEntry.name.toLowerCase() === stateFilter;
+            const matchSlug = stateEntry.slug === slugify(stateFilter);
+            if (!matchAbbrev && !matchName && !matchSlug)
+                continue;
+        }
+        const stateFile = atlas.byStateSlug.get(stateEntry.slug);
+        if (!stateFile)
+            continue;
+        const covered = stateFile.counties.filter((c) => c.endpoints.length > 0);
+        for (const c of covered) {
+            const ownerCoverage = c.endpoints.some((ep) => ownerFieldFrom(ep))
+                ? "owner+APN"
+                : "APN only";
+            rows.push(`${c.state} | ${c.county.padEnd(20)} | ${c.countySlug.padEnd(24)} | ${ownerCoverage}`);
+        }
+    }
+    if (rows.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: stateFilter
+                        ? `No covered counties found for state "${state}". Check state name/abbreviation.`
+                        : "No counties found (unexpected — check atlas data).",
+                },
+            ],
+        };
+    }
+    const header = "ST | County               | Slug                     | Coverage";
+    const divider = "-".repeat(header.length);
+    const totals = `\nTotal: ${rows.length} counties`;
+    return {
+        content: [
+            {
+                type: "text",
+                text: [header, divider, ...rows, divider, totals].join("\n"),
+            },
+        ],
+    };
+});
+// ---------------------------------------------------------------------------
+// Tool: find_county
+// ---------------------------------------------------------------------------
+server.registerTool("find_county", {
+    title: "Find a county by name or FIPS",
+    description: "Fuzzy-matches a county by name (e.g. 'Kane', 'Cook County', 'Cook County IL') or by 5-digit FIPS code. Returns endpoint URLs, searchable field names, owner field, sample query URL, and license info.",
+    inputSchema: {
+        query: z
+            .string()
+            .min(2)
+            .describe("County name, 'County Name State' (e.g. 'Kane IL'), or 5-digit FIPS code"),
+    },
+}, ({ query }) => {
+    const q = query.trim().toLowerCase();
+    // FIPS lookup
+    const isFips = /^\d{5}$/.test(q);
+    const matches = [];
+    for (const stateEntry of atlasIndex.states) {
+        if (!stateEntry.populated)
+            continue;
+        const stateFile = atlas.byStateSlug.get(stateEntry.slug);
+        if (!stateFile)
+            continue;
+        for (const county of stateFile.counties) {
+            if (isFips) {
+                if (county.countyFips === q)
+                    matches.push(county);
+                continue;
+            }
+            // Parse optional state suffix: "Kane IL" or "Kane Illinois"
+            let countyPart = q;
+            let statePart = null;
+            const spaceIdx = q.lastIndexOf(" ");
+            if (spaceIdx > 0) {
+                const last = q.slice(spaceIdx + 1);
+                if (last.length === 2 || last.length > 3) {
+                    countyPart = q.slice(0, spaceIdx);
+                    statePart = last;
+                }
+            }
+            if (statePart) {
+                const stateOk = stateEntry.abbrev.toLowerCase() === statePart ||
+                    stateEntry.name.toLowerCase() === statePart ||
+                    stateEntry.slug === slugify(statePart);
+                if (!stateOk)
+                    continue;
+            }
+            const slug = countySlugFromName(countyPart);
+            if (county.countySlug === slug ||
+                county.county.toLowerCase() === countyPart ||
+                county.county.toLowerCase().startsWith(countyPart)) {
+                matches.push(county);
+            }
+        }
+    }
+    if (matches.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `No county matched "${query}".\n` +
+                        `Try: "Kane IL", "Cook County IL", "17031" (FIPS), or use list_counties to browse.`,
+                },
+            ],
+        };
+    }
+    const text = matches.map(formatCountySummary).join("\n\n" + "=".repeat(60) + "\n\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: matches.length > 1 ? `${matches.length} matches:\n\n${text}` : text,
+            },
+        ],
+    };
+});
+// ---------------------------------------------------------------------------
+// Tool: get_parcel_endpoint
+// ---------------------------------------------------------------------------
+server.registerTool("get_parcel_endpoint", {
+    title: "Get parcel ArcGIS REST endpoint",
+    description: "Returns the full ArcGIS REST service URL, layer index, searchable field names, owner field, a ready sample ?where=…&f=json query, and the UrbanKit deep-link for a specific county.",
+    inputSchema: {
+        state: z
+            .string()
+            .describe("Two-letter state abbreviation (e.g. 'IL') or full state name"),
+        county: z
+            .string()
+            .describe("County name (e.g. 'Kane' or 'Kane County')"),
+    },
+}, ({ state, county }) => {
+    const stateSlug = slugify(state.trim());
+    const countySlug = countySlugFromName(county.trim());
+    // Try exact slug match first, then abbrev match
+    let countyRecord;
+    for (const stateEntry of atlasIndex.states) {
+        if (!stateEntry.populated)
+            continue;
+        const abbrevMatch = stateEntry.abbrev.toLowerCase() === state.trim().toLowerCase();
+        const slugMatch = stateEntry.slug === stateSlug;
+        const nameMatch = stateEntry.name.toLowerCase() === state.trim().toLowerCase();
+        if (!abbrevMatch && !slugMatch && !nameMatch)
+            continue;
+        const stateFile = atlas.byStateSlug.get(stateEntry.slug);
+        if (!stateFile)
+            continue;
+        countyRecord = stateFile.counties.find((c) => c.countySlug === countySlug);
+        if (countyRecord)
+            break;
+    }
+    if (!countyRecord) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `County "${county}" not found in state "${state}".\n` +
+                        `Use list_counties or find_county to verify the name.`,
+                },
+            ],
+        };
+    }
+    if (countyRecord.endpoints.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${countyRecord.county}, ${countyRecord.stateName} is in the atlas but has no verified REST endpoint yet.`,
+                },
+            ],
+        };
+    }
+    const lines = [
+        `${countyRecord.county} County, ${countyRecord.stateName} (${countyRecord.state})`,
+        `FIPS: ${countyRecord.countyFips ?? "n/a"}`,
+        "",
+    ];
+    countyRecord.endpoints.forEach((ep, i) => {
+        const ownerField = ownerFieldFrom(ep);
+        const sampleOwnerUrl = ownerField
+            ? buildArcgisOwnerQuery(ep, "SMITH")
+            : null;
+        lines.push(`Endpoint ${i + 1}:`);
+        lines.push(`  URL:         ${ep.url}`);
+        lines.push(`  Service:     ${ep.serviceType}`);
+        lines.push(`  Layer index: ${ep.layerIndex}`);
+        lines.push(`  Layer name:  ${ep.layerName}`);
+        lines.push(`  Status:      ${ep.status} (verified ${ep.lastVerified})`);
+        lines.push(`  CORS:        ${ep.corsEnabled === null ? "unknown" : ep.corsEnabled}`);
+        lines.push(`  License:     ${ep.license}${ep.licenseUrl ? ` (${ep.licenseUrl})` : ""}`);
+        lines.push("");
+        lines.push("  Searchable fields:");
+        ep.searchFields
+            .filter((sf) => sf.searchable)
+            .forEach((sf) => lines.push(`    ${sf.name.padEnd(20)} – ${sf.label}`));
+        lines.push("");
+        lines.push(`  Owner field: ${ownerField ?? "NONE — PIN-only county"}`);
+        if (ep.sampleQuery) {
+            lines.push("");
+            lines.push("  Sample query (from atlas):");
+            lines.push(`    ${ep.sampleQuery}`);
+        }
+        if (sampleOwnerUrl) {
+            lines.push("");
+            lines.push('  Sample owner query (SMITH — replace with target name):');
+            lines.push(`    ${sampleOwnerUrl}`);
+        }
+        lines.push("");
+        lines.push(`  UrbanKit deep-link: https://urbankitstudio.com/tools/parcel-lookup?endpoint=${encodeURIComponent(ep.url)}${ownerField ? `&fieldHint=${ownerField}` : ""}`);
+        if (i < countyRecord.endpoints.length - 1)
+            lines.push("\n" + "-".repeat(40));
+    });
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+    };
+});
+// ---------------------------------------------------------------------------
+// Tool: build_owner_query
+// ---------------------------------------------------------------------------
+server.registerTool("build_owner_query", {
+    title: "Build ArcGIS owner name query URL",
+    description: "Constructs the exact ArcGIS REST query URL using that county's verified owner/taxpayer field. Returns a URL you can open in a browser or fetch directly. The query uses UPPER(field) LIKE UPPER('%NAME%') — case-insensitive partial match.",
+    inputSchema: {
+        state: z
+            .string()
+            .describe("Two-letter state abbreviation (e.g. 'IL') or full state name"),
+        county: z
+            .string()
+            .describe("County name (e.g. 'Kane' or 'Kane County')"),
+        owner_name: z
+            .string()
+            .min(2)
+            .describe("Owner/taxpayer name to search for (partial match, case-insensitive)"),
+    },
+}, ({ state, county, owner_name }) => {
+    const stateInput = state.trim();
+    const countySlug = countySlugFromName(county.trim());
+    let countyRecord;
+    for (const stateEntry of atlasIndex.states) {
+        if (!stateEntry.populated)
+            continue;
+        const abbrevMatch = stateEntry.abbrev.toLowerCase() === stateInput.toLowerCase();
+        const slugMatch = stateEntry.slug === slugify(stateInput);
+        const nameMatch = stateEntry.name.toLowerCase() === stateInput.toLowerCase();
+        if (!abbrevMatch && !slugMatch && !nameMatch)
+            continue;
+        const stateFile = atlas.byStateSlug.get(stateEntry.slug);
+        if (!stateFile)
+            continue;
+        countyRecord = stateFile.counties.find((c) => c.countySlug === countySlug);
+        if (countyRecord)
+            break;
+    }
+    if (!countyRecord) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `County "${county}" not found in state "${state}". Use find_county to verify.`,
+                },
+            ],
+        };
+    }
+    const results = [];
+    for (const ep of countyRecord.endpoints) {
+        const ownerField = ownerFieldFrom(ep);
+        if (!ownerField) {
+            results.push(`Endpoint: ${ep.url}\nNote: No owner/taxpayer field available in this county — PIN-only lookup. Try searching by parcel number instead.`);
+            continue;
+        }
+        const queryUrl = buildArcgisOwnerQuery(ep, owner_name);
+        const where = `UPPER(${ownerField}) LIKE UPPER('%${owner_name}%')`;
+        results.push([
+            `County:      ${countyRecord.county}, ${countyRecord.stateName}`,
+            `Owner field: ${ownerField}`,
+            `WHERE clause: ${where}`,
+            ``,
+            `Query URL:`,
+            queryUrl,
+            ``,
+            `Notes:`,
+            `  - Returns up to 25 records`,
+            `  - Partial name match (e.g. "SMITH" matches "SMITH JOHN" and "BLACKSMITH LLC")`,
+            `  - Case-insensitive`,
+            `  - Add &token=<your-token> if the service requires auth (this county is public)`,
+        ].join("\n"));
+    }
+    if (results.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${countyRecord.county}, ${countyRecord.stateName} has no REST endpoints in the atlas yet.`,
+                },
+            ],
+        };
+    }
+    return {
+        content: [{ type: "text", text: results.join("\n\n" + "=".repeat(60) + "\n\n") }],
+    };
+});
+// ---------------------------------------------------------------------------
+// Connect and run
+// ---------------------------------------------------------------------------
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // MCP protocol runs over stdin/stdout; stderr is safe for diagnostics
+    process.stderr.write("mcp-atlas server started (stdio)\n");
+}
+main().catch((err) => {
+    process.stderr.write(`mcp-atlas fatal error: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@urbankitstudio/mcp-atlas",
+  "version": "0.1.0",
+  "description": "Query 137 verified US county parcel ArcGIS REST endpoints — owner/APN lookup — via MCP",
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "parcel",
+    "gis",
+    "arcgis",
+    "county",
+    "apn",
+    "address-to-parcel",
+    "property-data",
+    "real-estate",
+    "esri"
+  ],
+  "homepage": "https://urbankitstudio.com/parcel-atlas",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LEOyrh/urbankitstudio.git",
+    "directory": "packages/mcp-atlas"
+  },
+  "bugs": {
+    "url": "https://github.com/LEOyrh/urbankitstudio/issues"
+  },
+  "author": "Leo Yong <leoyrhbiz@gmail.com>",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/server.js",
+  "types": "./dist/server.d.ts",
+  "bin": {
+    "mcp-atlas": "./dist/server.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "smoke": "node test/smoke.mjs",
+    "prepublishOnly": "npm run typecheck && npm run build && npm run smoke"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@urbankitstudio/atlas": "^0.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.0",
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}