aipatterns-mcp-server 1.0.0

package/README.md

@@ -0,0 +1,82 @@
+# aipatterns.com.au MCP Server
+
+A Model Context Protocol (MCP) server that exposes the [aipatterns.com.au](https://aipatterns.com.au) pattern library, AU AI incidents, sector benchmarks, and regulatory changes as tools callable by Claude, Cursor, GitHub Copilot, and other MCP-compatible AI assistants.
+
+## What it provides
+
+| Tool | Description |
+|------|-------------|
+| `search_patterns` | Full-text search across the pattern library (title, description, content) |
+| `get_pattern` | Retrieve full detail + implementation guidance for a specific pattern |
+| `get_incidents` | Notable Australian AI incidents with linked patterns and regulatory outcomes |
+| `get_sector_benchmark` | AU AI Maturity Index scores for banking, insurance, government, retail, healthcare, utilities |
+| `get_regulatory_changes` | APRA CPS 230, OAIC Privacy Act reform, ASIC INFO 183, TGA SaMD, and more |
+
+No database connection or network calls are required at runtime — all data is served from the local pattern files and hardcoded seed data.
+
+## Installation
+
+```bash
+cd mcp-server
+npm install
+npm run build   # compiles index.ts → index.js
+```
+
+## Add to Claude Desktop
+
+Edit `~/.config/claude/claude_desktop_config.json` (macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "aipatterns": {
+      "command": "node",
+      "args": ["/absolute/path/to/eaapl-web/mcp-server/index.js"]
+    }
+  }
+}
+```
+
+Replace `/absolute/path/to/eaapl-web` with the actual path on your machine, then restart Claude Desktop.
+
+## Add to Cursor
+
+Create or edit `.cursor/mcp.json` in your project root:
+
+```json
+{
+  "mcpServers": {
+    "aipatterns": {
+      "command": "node",
+      "args": ["/absolute/path/to/eaapl-web/mcp-server/index.js"]
+    }
+  }
+}
+```
+
+## Add to GitHub Copilot (VS Code MCP extension)
+
+Add to your VS Code `settings.json`:
+
+```json
+{
+  "mcp.servers": {
+    "aipatterns": {
+      "command": "node",
+      "args": ["/absolute/path/to/eaapl-web/mcp-server/index.js"],
+      "transport": "stdio"
+    }
+  }
+}
+```
+
+## Development
+
+```bash
+npm run dev    # runs via tsx (no build step needed)
+npm run build  # compile TS → JS for production use
+```
+
+## Transport
+
+stdio — the server reads JSON-RPC from stdin and writes responses to stdout. stderr is used for diagnostic messages only.

package/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * aipatterns.com.au MCP Server
+ * Exposes pattern library, incidents, sector benchmarks, and regulatory changes
+ * as tools callable by Claude, Cursor, GitHub Copilot, and other MCP clients.
+ *
+ * Transport: stdio (no HTTP calls, no DB connection required)
+ */
+export {};

package/index.js

@@ -0,0 +1,589 @@
+#!/usr/bin/env node
+/**
+ * aipatterns.com.au MCP Server
+ * Exposes pattern library, incidents, sector benchmarks, and regulatory changes
+ * as tools callable by Claude, Cursor, GitHub Copilot, and other MCP clients.
+ *
+ * Transport: stdio (no HTTP calls, no DB connection required)
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { readdir, readFile } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PATTERNS_DIR = join(__dirname, "..", "content", "patterns");
+const SECTOR_BENCHMARKS = {
+    banking: {
+        sector: "banking",
+        overall: 57.3,
+        adoption: 60.1,
+        governance: 57.9,
+        investment: 60.6,
+        incidents: 48.4,
+        rank: 1,
+        national_average: {
+            overall: 41.8,
+            adoption: 40.9,
+            governance: 45.5,
+            investment: 41.3,
+            incidents: 38.9,
+        },
+    },
+    insurance: {
+        sector: "insurance",
+        overall: 46.7,
+        adoption: 48.5,
+        governance: 47.0,
+        investment: 48.9,
+        incidents: 41.1,
+        rank: 2,
+        national_average: {
+            overall: 41.8,
+            adoption: 40.9,
+            governance: 45.5,
+            investment: 41.3,
+            incidents: 38.9,
+        },
+    },
+    government: {
+        sector: "government",
+        overall: 33.5,
+        adoption: 25.4,
+        governance: 47.9,
+        investment: 24.1,
+        incidents: 39.3,
+        rank: 5,
+        national_average: {
+            overall: 41.8,
+            adoption: 40.9,
+            governance: 45.5,
+            investment: 41.3,
+            incidents: 38.9,
+        },
+    },
+    retail: {
+        sector: "retail",
+        overall: 39.4,
+        adoption: 43.1,
+        governance: 35.0,
+        investment: 42.6,
+        incidents: 35.1,
+        rank: 4,
+        national_average: {
+            overall: 41.8,
+            adoption: 40.9,
+            governance: 45.5,
+            investment: 41.3,
+            incidents: 38.9,
+        },
+    },
+    healthcare: {
+        sector: "healthcare",
+        overall: 42.3,
+        adoption: 40.2,
+        governance: 48.3,
+        investment: 41.4,
+        incidents: 38.9,
+        rank: 3,
+        national_average: {
+            overall: 41.8,
+            adoption: 40.9,
+            governance: 45.5,
+            investment: 41.3,
+            incidents: 38.9,
+        },
+    },
+    utilities: {
+        sector: "utilities",
+        overall: 31.3,
+        adoption: 28.0,
+        governance: 37.1,
+        investment: 29.9,
+        incidents: 30.8,
+        rank: 6,
+        national_average: {
+            overall: 41.8,
+            adoption: 40.9,
+            governance: 45.5,
+            investment: 41.3,
+            incidents: 38.9,
+        },
+    },
+};
+const AU_INCIDENTS = [
+    {
+        id: "robodebt",
+        title: "Robodebt Automated Debt Recovery Scheme",
+        sector: "government",
+        severity: "critical",
+        summary: "The Australian Government's automated welfare debt recovery system incorrectly raised debts against ~470,000 welfare recipients by income-averaging ATO data without human review. A Royal Commission found the scheme unlawful, resulting in $1.8B in repayments and criminal referrals of senior public servants.",
+        regulatory_bodies: ["OAIC", "ATO", "Services Australia"],
+        pattern_slugs: [
+            "human-in-the-loop/human-in-the-loop-gateway",
+            "compliance/algorithmic-impact-assessment",
+            "governance/model-governance-framework",
+        ],
+        outcome: "Royal Commission 2023. $1.8B repaid. Class action settled. Multiple criminal referrals. Foundational AU AI governance case study.",
+        year: 2019,
+    },
+    {
+        id: "medibank-breach",
+        title: "Medibank AI-Adjacent Data Breach",
+        sector: "healthcare",
+        severity: "critical",
+        summary: "Hackers accessed personal and health claims data of 9.7 million Medibank customers via stolen credentials. AI-powered anomaly detection failed to flag the lateral movement. OAIC commenced enforcement action; Medibank faces potential $21.5M+ in penalties under the Privacy Act.",
+        regulatory_bodies: ["OAIC", "ASIC", "APRA"],
+        pattern_slugs: [
+            "security/ai-security-policy-enforcement",
+            "observability/ai-audit-trail",
+            "governance/model-governance-framework",
+        ],
+        outcome: "9.7M records exposed. OAIC enforcement action commenced 2023. ASIC litigation filed. Potential penalties exceed $21.5M.",
+        year: 2022,
+    },
+    {
+        id: "anz-credit-bias",
+        title: "ANZ Credit Decisioning Algorithmic Bias Review",
+        sector: "banking",
+        severity: "high",
+        summary: "ASIC's 2023 shadow-shopping study found ANZ's AI-assisted credit decisioning produced statistically significant disparate outcomes for customers from certain postcodes and demographic groups. The model lacked explainability tooling required under updated INFO 183 guidance. ANZ voluntarily remediated ~12,000 customer files.",
+        regulatory_bodies: ["ASIC", "APRA"],
+        pattern_slugs: [
+            "governance/explainability-layer",
+            "compliance/algorithmic-impact-assessment",
+            "human-in-the-loop/human-in-the-loop-gateway",
+        ],
+        outcome: "Voluntary remediation of 12,000 files. ASIC infringement notice. Enhanced explainability tooling mandated in enforceable undertaking.",
+        year: 2023,
+    },
+    {
+        id: "cba-payments-blocked",
+        title: "CBA AI Fraud Model Mass Payment Blocking",
+        sector: "banking",
+        severity: "high",
+        summary: "CBA's real-time AI fraud detection model experienced a model drift event following a data pipeline change, incorrectly flagging ~85,000 legitimate payments as fraudulent over a 6-hour window. 40,000 customers were unable to access funds. APRA required a post-incident model risk review under CPS 230.",
+        regulatory_bodies: ["APRA", "ASIC", "RBA"],
+        pattern_slugs: [
+            "observability/model-performance-monitor",
+            "agentic-ai/agent-checkpoint-and-recovery",
+            "governance/model-governance-framework",
+        ],
+        outcome: "85,000 payments blocked. APRA CPS 230 model risk review required. Internal incident report published. Model drift detection controls mandated.",
+        year: 2024,
+    },
+    {
+        id: "nsw-chatgpt-breach",
+        title: "NSW Government ChatGPT Sensitive Data Exposure",
+        sector: "government",
+        severity: "high",
+        summary: "NSW public servants submitted sensitive cabinet documents, legal advice, and citizen PII into ChatGPT without authorisation. The NSWO Privacy Commissioner found the agency breached the PPIP Act. Subsequently NSW DCS issued a whole-of-government AI acceptable use policy and mandatory AI literacy training for APS staff.",
+        regulatory_bodies: ["NSW Privacy Commissioner", "OAIC", "NSW DCS"],
+        pattern_slugs: [
+            "security/ai-security-policy-enforcement",
+            "governance/model-governance-framework",
+            "compliance/data-minimisation-in-ai-pipelines",
+        ],
+        outcome: "PPIP Act breach finding. Mandatory AI acceptable use policy issued across NSW Government. Mandatory AI literacy training for 100,000+ APS staff.",
+        year: 2023,
+    },
+];
+const REGULATORY_CHANGES = [
+    {
+        id: "apra-cps-230",
+        title: "APRA CPS 230 Operational Risk Management",
+        regulator: "APRA",
+        framework: "CPS 230",
+        impact_level: "critical",
+        sectors: ["banking", "insurance"],
+        summary: "APRA CPS 230 (effective July 2025) requires all ADIs, insurers, and super funds to map every material service provider — including AI vendors — against business continuity obligations. AI systems affecting operational resilience must have documented fallback procedures, model risk registers, and board-level accountability. Non-compliance triggers supervisory escalation.",
+        effective_date: "2025-07-01",
+        url: "https://www.apra.gov.au/cps-230",
+    },
+    {
+        id: "oaic-ai-privacy",
+        title: "OAIC Automated Decision-Making Disclosure Obligations",
+        regulator: "OAIC",
+        framework: "Privacy Act Review — Reform Package",
+        impact_level: "high",
+        sectors: ["government", "healthcare", "banking"],
+        summary: "The Privacy Act Reform Package (2024–2025) moves automated decision-making disclosure from guidance to enforceable obligation for entities with >$3M annual turnover. Organisations must disclose when AI systems make or substantially influence decisions affecting individuals, provide meaningful explanation on request, and maintain an AI decision register auditable by the OAIC.",
+        effective_date: "2025-12-01",
+        url: "https://www.ag.gov.au/rights-and-protections/privacy",
+    },
+    {
+        id: "asic-info-183",
+        title: "ASIC INFO 183 AI Governance in Financial Services",
+        regulator: "ASIC",
+        framework: "INFO 183 (updated 2024)",
+        impact_level: "high",
+        sectors: ["banking", "insurance", "retail"],
+        summary: "ASIC's updated INFO 183 (2024) and its September 2023 shadow shopping study found 22% of AI-generated financial advice failing the 'best interest' duty. ASIC has issued 6 infringement notices tied to undisclosed AI use in client-facing decisions. Financial services licensees must maintain explainability documentation for all AI-influenced client decisions and conduct annual model risk reviews.",
+        effective_date: "2024-03-01",
+        url: "https://www.asic.gov.au/regulatory-resources/financial-services/digital-advice",
+    },
+    {
+        id: "tga-samd",
+        title: "TGA AI-Enabled Software as a Medical Device (SaMD) Framework",
+        regulator: "TGA",
+        framework: "SaMD Guidance (updated Jan 2024)",
+        impact_level: "high",
+        sectors: ["healthcare"],
+        summary: "TGA's updated SaMD framework (Jan 2024) classifies AI diagnostic tools under Class IIb or Class III depending on clinical risk — mandating clinical validation, post-market surveillance, and AU-specific training data requirements. 74 SaMD applications pending as of Q1 2026. Adaptive AI models that learn post-deployment require separate re-registration under the framework.",
+        effective_date: "2024-01-15",
+        url: "https://www.tga.gov.au/resources/resource/guidance/software-medical-device-guidance",
+    },
+    {
+        id: "privacy-act-reform",
+        title: "Privacy Act Reform — AI Provisions",
+        regulator: "OAIC",
+        framework: "Privacy Act 1988 (reformed)",
+        impact_level: "critical",
+        sectors: ["banking", "insurance", "government", "retail", "healthcare", "utilities"],
+        summary: "Comprehensive Privacy Act reform introduces a direct right of action for individuals, statutory tort for serious invasions of privacy, and specific provisions on AI profiling and inferred data. Organisations using AI to infer sensitive attributes (health, financial stress, political views) must obtain explicit consent. Reform package expected to pass in 2025 with 12-month compliance transition.",
+        effective_date: "2026-01-01",
+        url: "https://www.ag.gov.au/rights-and-protections/privacy",
+    },
+];
+function parsePatternFile(raw) {
+    const lines = raw.split("\n");
+    // Title from H1: # [EAAPL-XXXNNN] Pattern Name
+    const h1 = lines.find((l) => l.startsWith("# "));
+    const title = h1
+        ? h1.replace(/^#\s*/, "").replace(/\[[^\]]+\]\s*/, "").trim()
+        : "";
+    // Bold field parser: **FieldName:** value
+    const getField = (name) => {
+        const line = lines.find((l) => l.toLowerCase().startsWith(`**${name.toLowerCase()}:**`));
+        return line ? line.replace(/^\*\*[^*]+:\*\*\s*/, "").trim() : "";
+    };
+    const maturity = getField("Maturity") || getField("Status") || "";
+    // Regulatory from **Regulatory Relevance:** APRA CPS 230, ISO/IEC 42001
+    const regRaw = getField("Regulatory Relevance");
+    const regulatory = regRaw
+        ? regRaw.split(",").map((s) => s.replace(/`/g, "").trim()).filter(Boolean)
+        : [];
+    // Description from Executive Summary section
+    const summaryIdx = lines.findIndex((l) => /^##\s+.*executive summary/i.test(l));
+    let description = "";
+    if (summaryIdx !== -1) {
+        const bodyLines = [];
+        for (let i = summaryIdx + 1; i < lines.length; i++) {
+            if (lines[i].startsWith("##"))
+                break;
+            bodyLines.push(lines[i]);
+        }
+        description = bodyLines
+            .join(" ")
+            .replace(/\s+/g, " ")
+            .trim()
+            .slice(0, 300);
+    }
+    return { title, description, maturity, regulatory, content: raw };
+}
+function getContent(raw) {
+    return raw;
+}
+async function listPatternFiles(dir, base = "") {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const sub = await listPatternFiles(join(dir, entry.name), base ? `${base}/${entry.name}` : entry.name);
+            files.push(...sub);
+        }
+        else if (entry.name.endsWith(".md") || entry.name.endsWith(".mdx")) {
+            const slug = `${base ? base + "/" : ""}${entry.name.replace(/\.mdx?$/, "")}`;
+            files.push(slug);
+        }
+    }
+    return files;
+}
+async function readPattern(slug) {
+    for (const ext of [".md", ".mdx"]) {
+        try {
+            const raw = await readFile(join(PATTERNS_DIR, slug + ext), "utf8");
+            return parsePatternFile(raw);
+        }
+        catch {
+            // try next extension
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
+const server = new Server({ name: "aipatterns-mcp-server", version: "1.0.0" }, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "search_patterns",
+            description: "Search the aipatterns.com.au AI pattern library. Returns matching patterns with slug, title, description, maturity level, and category. Useful for finding design patterns relevant to a specific AI use case, capability, or compliance concern.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Search term to match against pattern title, description, or content",
+                    },
+                    category: {
+                        type: "string",
+                        description: "Optional category filter (e.g. agentic-ai, governance, security, rag, observability, compliance, human-in-the-loop)",
+                    },
+                    maturity: {
+                        type: "string",
+                        description: "Optional maturity filter (e.g. production, beta, experimental)",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "get_pattern",
+            description: "Retrieve full detail of a specific AI pattern from aipatterns.com.au, including implementation guidance and regulatory context. Use the slug returned by search_patterns.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    slug: {
+                        type: "string",
+                        description: 'Pattern slug, e.g. "agentic-ai/agent-checkpoint-and-recovery"',
+                    },
+                },
+                required: ["slug"],
+            },
+        },
+        {
+            name: "get_incidents",
+            description: "Retrieve notable Australian AI incidents. Useful for understanding real-world failures, regulatory enforcement actions, and which patterns could have prevented the incident.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sector: {
+                        type: "string",
+                        description: "Filter by sector: banking, insurance, government, retail, healthcare, utilities",
+                    },
+                    severity: {
+                        type: "string",
+                        description: "Filter by severity: critical, high, medium, low",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Maximum number of incidents to return (default 5)",
+                    },
+                },
+            },
+        },
+        {
+            name: "get_sector_benchmark",
+            description: "Get the AU AI Maturity Index benchmark score for a specific sector. Returns overall score, dimension scores (adoption, governance, investment, incidents), sector rank, and national averages. Scores computed from Q2 2026 evidence base.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sector: {
+                        type: "string",
+                        description: "One of: banking, insurance, government, retail, healthcare, utilities",
+                    },
+                },
+                required: ["sector"],
+            },
+        },
+        {
+            name: "get_regulatory_changes",
+            description: "Retrieve recent and upcoming Australian AI regulatory changes (APRA, OAIC, ASIC, TGA, Privacy Act reform). Useful for understanding compliance obligations when building AI systems for the Australian market.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    regulator: {
+                        type: "string",
+                        description: "Filter by regulator abbreviation: APRA, OAIC, ASIC, TGA",
+                    },
+                    impact_level: {
+                        type: "string",
+                        description: "Filter by impact level: critical, high, medium, low",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Maximum number of changes to return (default 5)",
+                    },
+                },
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "search_patterns": {
+                const { query, category, maturity } = args;
+                const slugs = await listPatternFiles(PATTERNS_DIR);
+                const results = [];
+                for (const slug of slugs) {
+                    if (results.length >= 10)
+                        break;
+                    const slugCategory = slug.includes("/") ? slug.split("/")[0] : "";
+                    if (category && slugCategory !== category)
+                        continue;
+                    const parsed = await readPattern(slug);
+                    if (!parsed)
+                        continue;
+                    if (maturity && parsed.maturity.toLowerCase() !== maturity.toLowerCase())
+                        continue;
+                    const q = query.toLowerCase();
+                    const matchable = `${parsed.title} ${parsed.description} ${parsed.content}`.toLowerCase();
+                    if (!matchable.includes(q))
+                        continue;
+                    results.push({
+                        slug,
+                        title: parsed.title || slug,
+                        description: parsed.description,
+                        maturity: parsed.maturity,
+                        category: slugCategory,
+                    });
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(results, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "get_pattern": {
+                const { slug } = args;
+                const parsed = await readPattern(slug);
+                if (!parsed) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({ error: `Pattern not found: ${slug}` }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const detail = {
+                    slug,
+                    title: parsed.title || slug,
+                    description: parsed.description,
+                    maturity: parsed.maturity,
+                    category: slug.includes("/") ? slug.split("/")[0] : "",
+                    regulatory: parsed.regulatory,
+                    content: parsed.content.slice(0, 4000),
+                };
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(detail, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "get_incidents": {
+                const { sector, severity, limit = 5 } = args;
+                let results = AU_INCIDENTS;
+                if (sector)
+                    results = results.filter((i) => i.sector === sector);
+                if (severity)
+                    results = results.filter((i) => i.severity === severity);
+                results = results.slice(0, limit);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(results, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "get_sector_benchmark": {
+                const { sector } = args;
+                const benchmark = SECTOR_BENCHMARKS[sector.toLowerCase()];
+                if (!benchmark) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: `Unknown sector: ${sector}. Valid sectors: ${Object.keys(SECTOR_BENCHMARKS).join(", ")}`,
+                                }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(benchmark, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "get_regulatory_changes": {
+                const { regulator, impact_level, limit = 5 } = args;
+                let results = REGULATORY_CHANGES;
+                if (regulator) {
+                    results = results.filter((r) => r.regulator.toLowerCase() === regulator.toLowerCase());
+                }
+                if (impact_level) {
+                    results = results.filter((r) => r.impact_level === impact_level);
+                }
+                results = results.slice(0, limit);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(results, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ error: `Unknown tool: ${name}` }),
+                        },
+                    ],
+                    isError: true,
+                };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ error: message }),
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// ---------------------------------------------------------------------------
+// Bootstrap
+// ---------------------------------------------------------------------------
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // MCP servers communicate over stdio; stderr is safe for diagnostics
+    process.stderr.write("aipatterns MCP server running on stdio\n");
+}
+main().catch((err) => {
+    process.stderr.write(`Fatal: ${err}\n`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "aipatterns-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for aipatterns.com.au — search 138 AU enterprise AI patterns, get sector benchmarks, incidents, and regulatory changes via Claude, Cursor, or any MCP client.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "aipatterns-mcp-server": "index.js"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node index.js",
+    "dev": "tsx index.ts"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai-patterns",
+    "australia",
+    "enterprise-ai",
+    "claude",
+    "governance",
+    "regulatory"
+  ],
+  "author": "uchit",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/uchit86/aipatterns-mcp-server"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "tsx": "^4.0.0",
+    "@types/node": "^20.0.0"
+  }
+}