@iconmind/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,2053 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/resources.ts
+import { ListResourcesRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// ../icons/dist/metadata.json
+var metadata_default = {
+  version: "0.1.0",
+  generatedAt: "2026-08-24T02:01:55.463Z",
+  counts: {
+    total: 53,
+    byCategory: {
+      ai: 19,
+      agents: 16,
+      mcp: 9,
+      rag: 9,
+      data: 0,
+      devops: 0,
+      cloud: 0,
+      security: 0,
+      automation: 0,
+      analytics: 0,
+      devtools: 0,
+      interface: 0
+    }
+  },
+  categories: [
+    {
+      slug: "ai",
+      name: "AI & LLM",
+      count: 19,
+      subcategories: [
+        {
+          slug: "model",
+          count: 2
+        },
+        {
+          slug: "inference",
+          count: 2
+        },
+        {
+          slug: "prompt",
+          count: 3
+        },
+        {
+          slug: "token",
+          count: 2
+        },
+        {
+          slug: "context",
+          count: 1
+        },
+        {
+          slug: "embedding",
+          count: 2
+        },
+        {
+          slug: "training",
+          count: 3
+        },
+        {
+          slug: "evaluation",
+          count: 2
+        },
+        {
+          slug: "safety",
+          count: 1
+        },
+        {
+          slug: "multimodal",
+          count: 1
+        }
+      ]
+    },
+    {
+      slug: "agents",
+      name: "Agents",
+      count: 16,
+      subcategories: [
+        {
+          slug: "agent-core",
+          count: 1
+        },
+        {
+          slug: "multi-agent",
+          count: 2
+        },
+        {
+          slug: "planning",
+          count: 3
+        },
+        {
+          slug: "reflection",
+          count: 1
+        },
+        {
+          slug: "memory",
+          count: 1
+        },
+        {
+          slug: "tool-use",
+          count: 1
+        },
+        {
+          slug: "communication",
+          count: 2
+        },
+        {
+          slug: "lifecycle",
+          count: 5
+        }
+      ]
+    },
+    {
+      slug: "mcp",
+      name: "MCP",
+      count: 9,
+      subcategories: [
+        {
+          slug: "server",
+          count: 1
+        },
+        {
+          slug: "client",
+          count: 2
+        },
+        {
+          slug: "resource",
+          count: 1
+        },
+        {
+          slug: "tool",
+          count: 2
+        },
+        {
+          slug: "prompt",
+          count: 1
+        },
+        {
+          slug: "transport",
+          count: 1
+        },
+        {
+          slug: "registry",
+          count: 1
+        }
+      ]
+    },
+    {
+      slug: "rag",
+      name: "RAG & Search",
+      count: 9,
+      subcategories: [
+        {
+          slug: "ingestion",
+          count: 1
+        },
+        {
+          slug: "chunking",
+          count: 2
+        },
+        {
+          slug: "retrieval",
+          count: 2
+        },
+        {
+          slug: "ranking",
+          count: 1
+        },
+        {
+          slug: "vector",
+          count: 1
+        },
+        {
+          slug: "knowledge",
+          count: 1
+        },
+        {
+          slug: "grounding",
+          count: 1
+        }
+      ]
+    }
+  ],
+  icons: [
+    {
+      slug: "agent",
+      category: "agents",
+      subcategory: "agent-core",
+      name: "Agent",
+      description: "An autonomous agent that acts on its own",
+      tags: [
+        "agent",
+        "autonomous",
+        "actor",
+        "entity",
+        "worker",
+        "bot"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Agent",
+      contentHash: "sha256:8c8c8f4e502a75e32b25312301116228bd3bd3ff554b6ba12c04446142e702b9",
+      structuralHash: "circle|path:MHLVLHLVZ",
+      elementCount: 2,
+      byteSize: 263,
+      related: [
+        "agent-run",
+        "agent-pause",
+        "agent-thinking",
+        "agent-stop"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "agent-hierarchy",
+      category: "agents",
+      subcategory: "multi-agent",
+      name: "Agent Hierarchy",
+      description: "Agents arranged in tiers with one above several others",
+      tags: [
+        "hierarchy",
+        "tree",
+        "supervisor",
+        "delegation",
+        "org chart",
+        "tiers"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "AgentHierarchy",
+      contentHash: "sha256:e0d9cd79b2829904ddf6b45899d9b269fdb86960df4b814e461e0962cf29818c",
+      structuralHash: "path:MHLVLHLVZ|path:MHLVLHLVZ|path:MHLVLHLVZ|path:MV|path:MVHV",
+      elementCount: 5,
+      byteSize: 382,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "agent-log",
+      category: "agents",
+      subcategory: "lifecycle",
+      name: "Agent Log",
+      description: "A time-ordered record of what an agent did",
+      tags: [
+        "log",
+        "history",
+        "trace",
+        "audit",
+        "timeline",
+        "record"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "AgentLog",
+      contentHash: "sha256:58b14074a948c3bbf0dd106a7a7e2226642027fd52bc2f4b0e28625ff0ffebcc",
+      structuralHash: "circle|path:MH|path:MH|path:MH|path:MVH",
+      elementCount: 5,
+      byteSize: 300,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "agent-message",
+      category: "agents",
+      subcategory: "communication",
+      name: "Agent Message",
+      description: "Something one agent says to another",
+      tags: [
+        "message",
+        "speak",
+        "communicate",
+        "send",
+        "utterance",
+        "reply"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "AgentMessage",
+      contentHash: "sha256:27d3ab29c4abf0888aec450688ca77838545269706ca02d4e391e43337949b62",
+      structuralHash: "path:MHLVLHLVLVZ|path:MHLVLHLVZ",
+      elementCount: 2,
+      byteSize: 278,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "agent-pause",
+      category: "agents",
+      subcategory: "lifecycle",
+      name: "Agent Pause",
+      description: "Suspend an agent and keep its state",
+      tags: [
+        "pause",
+        "suspend",
+        "hold",
+        "wait",
+        "freeze",
+        "resume"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "AgentPause",
+      contentHash: "sha256:f367143a3ad96edffbb229eb2a4597667f966f2cbde0ecaa38afdefeab0df416",
+      structuralHash: "path:MHLVLHLVZ|path:MV|path:MV",
+      elementCount: 3,
+      byteSize: 271,
+      related: [
+        "agent",
+        "agent-run",
+        "agent-thinking",
+        "agent-stop"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "agent-run",
+      category: "agents",
+      subcategory: "lifecycle",
+      name: "Agent Run",
+      description: "Start an agent and let it work",
+      tags: [
+        "run",
+        "start",
+        "execute",
+        "play",
+        "launch",
+        "active"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "AgentRun",
+      contentHash: "sha256:c3146241b4a048b7617f77af2610dc95b4efdee3a7aed03bb50522337ba04cac",
+      structuralHash: "path:MHLVLHLVZ|path:MLZ",
+      elementCount: 2,
+      byteSize: 265,
+      related: [
+        "agent",
+        "agent-pause",
+        "agent-thinking",
+        "agent-stop"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "agent-stop",
+      category: "agents",
+      subcategory: "lifecycle",
+      name: "Agent Stop",
+      description: "Halt an agent before it finishes",
+      tags: [
+        "stop",
+        "halt",
+        "cancel",
+        "abort",
+        "terminate",
+        "kill"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "AgentStop",
+      contentHash: "sha256:332c17e3596c72e847ca7c0069097839578cb51b6893e7c80aad5a7cfea52e76",
+      structuralHash: "path:MHLVLHLVZ|rect",
+      elementCount: 2,
+      byteSize: 278,
+      related: [
+        "agent",
+        "agent-run",
+        "agent-thinking",
+        "agent-pause"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "agent-thinking",
+      category: "agents",
+      subcategory: "lifecycle",
+      name: "Agent Thinking",
+      description: "An agent reasoning before it acts",
+      tags: [
+        "thinking",
+        "reasoning",
+        "processing",
+        "working",
+        "pending",
+        "deliberating"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "AgentThinking",
+      contentHash: "sha256:c935bb7dc5760fea16de973f866d32b62091939a831cffd2a75ec940143df9fa",
+      structuralHash: "circle|circle|circle|path:MHLVLHLVZ",
+      elementCount: 4,
+      byteSize: 334,
+      related: [
+        "agent",
+        "agent-run",
+        "agent-pause",
+        "agent-stop",
+        "context-window"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "benchmark",
+      category: "ai",
+      subcategory: "evaluation",
+      name: "Benchmark",
+      description: "A standard test models are ranked against",
+      tags: [
+        "benchmark",
+        "ranking",
+        "leaderboard",
+        "compare",
+        "podium",
+        "score"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Benchmark",
+      contentHash: "sha256:5eb26ed1e35b189c3e8f5e0662f4903e5205d7a47c0bee3e23106797d5973783",
+      structuralHash: "path:MVHVHVHVZ",
+      elementCount: 1,
+      byteSize: 221,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "chain-of-thought",
+      category: "ai",
+      subcategory: "prompt",
+      name: "Chain of Thought",
+      description: "Reasoning worked through one step at a time",
+      tags: [
+        "chain of thought",
+        "reasoning",
+        "steps",
+        "cot",
+        "stepwise",
+        "deliberate"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "ChainOfThought",
+      contentHash: "sha256:4a532fc19374e330dc5c4e98d4beb80e2ed170b189bf1aaaab3baa2207fcbc26",
+      structuralHash: "path:MHVHVHVH",
+      elementCount: 1,
+      byteSize: 221,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "chunk",
+      category: "rag",
+      subcategory: "chunking",
+      name: "Chunk",
+      description: "One piece of a document, sized to fit a model",
+      tags: [
+        "chunk",
+        "block",
+        "segment",
+        "passage",
+        "split",
+        "text block"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Chunk",
+      contentHash: "sha256:d2812abb2e7e826cb44ec1ab5484c047d28db0ee9f8197304b3442341a6910fb",
+      structuralHash: "path:MH|path:MH|rect",
+      elementCount: 3,
+      byteSize: 282,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "chunk-overlap",
+      category: "rag",
+      subcategory: "chunking",
+      name: "Chunk Overlap",
+      description: "Content shared between two consecutive document chunks",
+      tags: [
+        "chunk",
+        "overlap",
+        "intersection",
+        "sliding window",
+        "split",
+        "venn"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "ChunkOverlap",
+      contentHash: "sha256:8c71a1fa8a4bbcb2574d9d0aa9b3cbaf66750a5f5c9dddfc95a039b11d753bd7",
+      structuralHash: "circle|circle",
+      elementCount: 2,
+      byteSize: 249,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "context-window",
+      category: "ai",
+      subcategory: "context",
+      name: "Context Window",
+      description: "Span of tokens a model can see in a single call",
+      tags: [
+        "context",
+        "window",
+        "scope",
+        "token limit",
+        "prompt",
+        "boundary"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "ContextWindow",
+      contentHash: "sha256:a15b88ff7a040acaf6bd48e1391012539b27e3a5333536a3bf40588da4835673",
+      structuralHash: "circle|circle|path:MHAVAH|path:MHAVAH",
+      elementCount: 4,
+      byteSize: 357,
+      related: [
+        "subtask",
+        "agent-thinking"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "dataset",
+      category: "ai",
+      subcategory: "training",
+      name: "Dataset",
+      description: "A collection of records used to train or evaluate",
+      tags: [
+        "dataset",
+        "records",
+        "rows",
+        "corpus",
+        "samples",
+        "table"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Dataset",
+      contentHash: "sha256:0b4a61cf961be5fc61125d19658a6d1b53d6efc0f03a552c902bb0d5d22cb179",
+      structuralHash: "path:MH|path:MV|rect",
+      elementCount: 3,
+      byteSize: 275,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "document",
+      category: "rag",
+      subcategory: "ingestion",
+      name: "Document",
+      description: "A source file fed into a pipeline",
+      tags: [
+        "document",
+        "file",
+        "page",
+        "source",
+        "text",
+        "paper"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Document",
+      contentHash: "sha256:36f49b7315e023ccadf6f8d867f4f058529651346ac0dc94543ff37a11b64873",
+      structuralHash: "path:MHLVAHAVA|path:MVH",
+      elementCount: 2,
+      byteSize: 281,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "embedding",
+      category: "ai",
+      subcategory: "embedding",
+      name: "Embedding",
+      description: "Text turned into a vector of numbers",
+      tags: [
+        "embedding",
+        "vector",
+        "encode",
+        "representation",
+        "features",
+        "transform"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Embedding",
+      contentHash: "sha256:53348386a8ec7a9599f71f9a5f5272bd0da1dc41c2234ec6597b3954b2370ccd",
+      structuralHash: "circle|circle|circle|path:MH|rect",
+      elementCount: 5,
+      byteSize: 359,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "evaluation",
+      category: "ai",
+      subcategory: "evaluation",
+      name: "Evaluation",
+      description: "Scoring model output against expected results",
+      tags: [
+        "evaluation",
+        "eval",
+        "score",
+        "assess",
+        "check",
+        "grade"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Evaluation",
+      contentHash: "sha256:a1fce4baedafbfe369dac971285d4d8b0894a715bef6964052e14c00953464d5",
+      structuralHash: "path:MH|path:MH|path:ML|path:ML",
+      elementCount: 4,
+      byteSize: 287,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "fine-tuning",
+      category: "ai",
+      subcategory: "training",
+      name: "Fine Tuning",
+      description: "Adapting a trained model to a narrower task",
+      tags: [
+        "fine tuning",
+        "adapt",
+        "tune",
+        "adjust",
+        "specialise",
+        "lora"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "FineTuning",
+      contentHash: "sha256:eeb4831cc471c2bc3a6eda97b23efb3c341a11a5a029f17a12771cffad604be2",
+      structuralHash: "circle|path:MH|path:MVLLVZ",
+      elementCount: 3,
+      byteSize: 291,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "function-call",
+      category: "agents",
+      subcategory: "tool-use",
+      name: "Function Call",
+      description: "Structured function invocation emitted by a model",
+      tags: [
+        "function",
+        "call",
+        "invoke",
+        "parentheses",
+        "arguments",
+        "tool use"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "FunctionCall",
+      contentHash: "sha256:fb31383551ba6cc9ae747afec982f5c5d054ce951a2ead7639a02bfe085794e8",
+      structuralHash: "circle|path:MA|path:MA",
+      elementCount: 3,
+      byteSize: 289,
+      related: [
+        "guardrail"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "goal",
+      category: "agents",
+      subcategory: "planning",
+      name: "Goal",
+      description: "The outcome an agent is working toward",
+      tags: [
+        "goal",
+        "objective",
+        "target",
+        "flag",
+        "milestone",
+        "intent"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Goal",
+      contentHash: "sha256:791bd9e08aec2350df93b6f5ab8b2b20d1f1258984b46250a7ab7e2d699c7c91",
+      structuralHash: "path:MHLH|path:MV",
+      elementCount: 2,
+      byteSize: 237,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "guardrail",
+      category: "ai",
+      subcategory: "safety",
+      name: "Guardrail",
+      description: "A constraint that blocks unsafe model output",
+      tags: [
+        "guardrail",
+        "safety",
+        "block",
+        "constraint",
+        "shield",
+        "policy"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Guardrail",
+      contentHash: "sha256:af141c380672daef8416fdb498bc300720afd1b7202344be85d2ff102621493f",
+      structuralHash: "path:MH|path:MVCVZ",
+      elementCount: 2,
+      byteSize: 272,
+      related: [
+        "model",
+        "training",
+        "llm",
+        "function-call"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "human-approval",
+      category: "agents",
+      subcategory: "communication",
+      name: "Human Approval",
+      description: "A person signing off before an agent proceeds",
+      tags: [
+        "approval",
+        "human in the loop",
+        "sign off",
+        "confirm",
+        "review",
+        "consent"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "HumanApproval",
+      contentHash: "sha256:97eb881c18c4c7bce022c8ec9e20ebc3046f9557394620f4139ef19b44ccbe28",
+      structuralHash: "circle|path:MA|path:ML",
+      elementCount: 3,
+      byteSize: 287,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "inference",
+      category: "ai",
+      subcategory: "inference",
+      name: "Inference",
+      description: "Running input through a model to get output",
+      tags: [
+        "inference",
+        "predict",
+        "forward pass",
+        "run",
+        "serve",
+        "throughput"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Inference",
+      contentHash: "sha256:dbbb406bdce0de386964ff39c2900d6e6309a3e7b29ac01daa2f9fd028dfc8df",
+      structuralHash: "path:MH|path:MH|path:MVLVZ",
+      elementCount: 3,
+      byteSize: 276,
+      related: [
+        "tokenizer"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "knowledge-base",
+      category: "rag",
+      subcategory: "knowledge",
+      name: "Knowledge Base",
+      description: "Curated body of documents a system can draw on",
+      tags: [
+        "knowledge",
+        "book",
+        "reference",
+        "corpus",
+        "docs",
+        "library"
+      ],
+      aliases: [
+        "kb"
+      ],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "KnowledgeBase",
+      contentHash: "sha256:c932b54d257b06f0d2b4fbc8fd196b62bea41433bca4cdd0e866ffdb8483f783",
+      structuralHash: "path:MV|path:MVL|path:MVL",
+      elementCount: 3,
+      byteSize: 265,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "llm",
+      category: "ai",
+      subcategory: "model",
+      name: "LLM",
+      description: "A large language model",
+      tags: [
+        "llm",
+        "language model",
+        "text",
+        "generative",
+        "transformer",
+        "chat"
+      ],
+      aliases: [
+        "large-language-model"
+      ],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Llm",
+      contentHash: "sha256:973dea8f2c54963995948ef1bc664c1f0a0f0091a375b02e226974754dcc2722",
+      structuralHash: "path:MH|path:MH|path:MVLVZ",
+      elementCount: 3,
+      byteSize: 264,
+      related: [
+        "model",
+        "training",
+        "guardrail"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "mcp-capability",
+      category: "mcp",
+      subcategory: "transport",
+      name: "MCP Capability",
+      description: "What a server declares it can do during handshake",
+      tags: [
+        "capability",
+        "negotiate",
+        "declare",
+        "support",
+        "feature",
+        "handshake"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "McpCapability",
+      contentHash: "sha256:57ee94f8a4e07fae9256ad91d62b463f72f3c07db17007f7c342195be359c068",
+      structuralHash: "path:M|path:M|path:MH|rect",
+      elementCount: 4,
+      byteSize: 315,
+      related: [
+        "mcp-resource"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "mcp-client",
+      category: "mcp",
+      subcategory: "client",
+      name: "MCP Client",
+      description: "An application that consumes what MCP servers expose",
+      tags: [
+        "client",
+        "consumer",
+        "host",
+        "connect",
+        "caller",
+        "application"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "McpClient",
+      contentHash: "sha256:ba18b62cc80ac70c6059ccc7828e0e5dc3153029a6247d8b83309f98d250c3ee",
+      structuralHash: "path:MH|path:MH|path:MH|rect",
+      elementCount: 4,
+      byteSize: 293,
+      related: [
+        "mcp-tool"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "mcp-config",
+      category: "mcp",
+      subcategory: "registry",
+      name: "MCP Config",
+      description: "Settings that tell a client which servers to run",
+      tags: [
+        "config",
+        "settings",
+        "setup",
+        "options",
+        "manifest",
+        "preferences"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "McpConfig",
+      contentHash: "sha256:32b4872f41c36125d391c379af976fe510c66032b53b73828a068ef335799246",
+      structuralHash: "circle|circle|path:MH|path:MH|path:MH",
+      elementCount: 5,
+      byteSize: 307,
+      related: [
+        "token"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "mcp-connection",
+      category: "mcp",
+      subcategory: "client",
+      name: "MCP Connection",
+      description: "An open link between a client and a server",
+      tags: [
+        "connection",
+        "link",
+        "session",
+        "connected",
+        "channel",
+        "port"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "McpConnection",
+      contentHash: "sha256:6ef058abd716f3e17d45578ef318a4357b374295f454efe940d2df822875745a",
+      structuralHash: "path:MH|rect|rect",
+      elementCount: 3,
+      byteSize: 302,
+      related: [
+        "token"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "mcp-prompt",
+      category: "mcp",
+      subcategory: "prompt",
+      name: "MCP Prompt",
+      description: "A reusable prompt template an MCP server exposes",
+      tags: [
+        "prompt",
+        "template",
+        "reusable",
+        "expose",
+        "message",
+        "preset"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "McpPrompt",
+      contentHash: "sha256:ff2bd78da460cdaf1058ef5e3b97bfc5bf0cc8e5f2d5d711112a51af05506483",
+      structuralHash: "path:MH|path:MHLVLHLVLVZ",
+      elementCount: 2,
+      byteSize: 256,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "mcp-resource",
+      category: "mcp",
+      subcategory: "resource",
+      name: "MCP Resource",
+      description: "Data an MCP server exposes for clients to read",
+      tags: [
+        "resource",
+        "document",
+        "expose",
+        "read",
+        "context source",
+        "uri"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "McpResource",
+      contentHash: "sha256:5981fa56d151c2f0089cfbaa1beed2cca7d338165777f8b3202abaedc050fd45",
+      structuralHash: "path:MH|path:MH|path:MH|rect",
+      elementCount: 4,
+      byteSize: 303,
+      related: [
+        "mcp-capability"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "mcp-server",
+      category: "mcp",
+      subcategory: "server",
+      name: "MCP Server",
+      description: "A server that exposes resources, tools, and prompts over MCP",
+      tags: [
+        "server",
+        "host",
+        "expose",
+        "endpoint",
+        "provider",
+        "protocol"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "McpServer",
+      contentHash: "sha256:aea92db44c15e7b13caad99f1752847fb5c22ea181d6eaa4cf8e5c229faee5bd",
+      structuralHash: "path:MH|path:MH|path:MH|rect",
+      elementCount: 4,
+      byteSize: 296,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "mcp-tool",
+      category: "mcp",
+      subcategory: "tool",
+      name: "MCP Tool",
+      description: "Capability an MCP server exposes for clients to invoke",
+      tags: [
+        "tool",
+        "capability",
+        "plugin",
+        "puzzle",
+        "extension",
+        "invoke"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "McpTool",
+      contentHash: "sha256:258fe85e4557a7d7b304cad08c27eb676d369cb0bc66b07191da8d6633babcf1",
+      structuralHash: "path:MVHVAVHAZ",
+      elementCount: 1,
+      byteSize: 246,
+      related: [
+        "mcp-tool-call",
+        "mcp-client"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "mcp-tool-call",
+      category: "mcp",
+      subcategory: "tool",
+      name: "MCP Tool Call",
+      description: "Invoking a tool an MCP server exposes",
+      tags: [
+        "tool call",
+        "invoke",
+        "execute",
+        "run",
+        "request",
+        "dispatch"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "McpToolCall",
+      contentHash: "sha256:73d4e6f7a4c629dc577a45d06b9177abcc657ad5eca2cbf64fb630efc6801ad8",
+      structuralHash: "path:MVHVAVHAZ|path:MZ",
+      elementCount: 2,
+      byteSize: 272,
+      related: [
+        "mcp-tool"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "memory",
+      category: "agents",
+      subcategory: "memory",
+      name: "Memory",
+      description: "Memory an agent writes to and reads back",
+      tags: [
+        "memory",
+        "recall",
+        "state",
+        "store",
+        "remember",
+        "cells"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Memory",
+      contentHash: "sha256:82f75d4f980dfed62d1a24b1b9ba5a94833b96232be3a565832a38b0ffbc905a",
+      structuralHash: "path:MV|path:MV|path:MV|rect",
+      elementCount: 4,
+      byteSize: 303,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "model",
+      category: "ai",
+      subcategory: "model",
+      name: "Model",
+      description: "A machine learning model that turns input into output",
+      tags: [
+        "model",
+        "ml",
+        "neural network",
+        "weights",
+        "component",
+        "inference"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Model",
+      contentHash: "sha256:cf3de81aa4302f3057be7677ab6d603b5995ce3d887e1eede1c074ac0449b200",
+      structuralHash: "path:MVLVZ",
+      elementCount: 1,
+      byteSize: 224,
+      related: [
+        "llm",
+        "training",
+        "guardrail"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "multi-agent",
+      category: "agents",
+      subcategory: "multi-agent",
+      name: "Multi Agent",
+      description: "Several agents working on the same task",
+      tags: [
+        "multi agent",
+        "team",
+        "swarm",
+        "group",
+        "cluster",
+        "crew"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "MultiAgent",
+      contentHash: "sha256:850573f4dc92522a8aa741d751a4c19ba74a0a43cec6c13c2fff2d5fe480b74b",
+      structuralHash: "path:MHLVLHLVZ|path:MHLVLHLVZ|path:MHLVLHLVZ",
+      elementCount: 3,
+      byteSize: 338,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "multimodal",
+      category: "ai",
+      subcategory: "multimodal",
+      name: "Multimodal",
+      description: "A model that takes more than one kind of input",
+      tags: [
+        "multimodal",
+        "vision",
+        "audio",
+        "mixed input",
+        "cross modal",
+        "fusion"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Multimodal",
+      contentHash: "sha256:37a7e0d49c9c6b14edaed5fb9cec750763883f6e2562eee54a260bec94dafb50",
+      structuralHash: "circle|path:MVLVZ|rect",
+      elementCount: 3,
+      byteSize: 300,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "plan",
+      category: "agents",
+      subcategory: "planning",
+      name: "Plan",
+      description: "An ordered set of steps an agent intends to take",
+      tags: [
+        "plan",
+        "steps",
+        "checklist",
+        "todo",
+        "sequence",
+        "tasks"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Plan",
+      contentHash: "sha256:c2f4f80cd42b04927090decb8809a12d8a07f12f5b8e7088b7aa696080477156",
+      structuralHash: "path:MH|path:MH|path:MH|rect|rect|rect",
+      elementCount: 6,
+      byteSize: 396,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "prompt",
+      category: "ai",
+      subcategory: "prompt",
+      name: "Prompt",
+      description: "An instruction sent to a model",
+      tags: [
+        "prompt",
+        "instruction",
+        "input",
+        "query",
+        "command",
+        "ask"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Prompt",
+      contentHash: "sha256:94a53d183366de5842ca9d7b56fa27268d7ef86af10e1be47f456bb1ac52f019",
+      structuralHash: "path:M|path:MHLVLHLVHLVZ",
+      elementCount: 2,
+      byteSize: 266,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "reflection",
+      category: "agents",
+      subcategory: "reflection",
+      name: "Reflection",
+      description: "An agent reviewing its own output before continuing",
+      tags: [
+        "reflection",
+        "self review",
+        "critique",
+        "introspection",
+        "mirror",
+        "check"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Reflection",
+      contentHash: "sha256:fbd0df7a39414d376c45d33f2ec82bae9df85298d408aff05eeb4ed3dae29fe2",
+      structuralHash: "circle|path:MA|path:MH",
+      elementCount: 3,
+      byteSize: 270,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "reranker",
+      category: "rag",
+      subcategory: "ranking",
+      name: "Reranker",
+      description: "Model that reorders search results by relevance",
+      tags: [
+        "rerank",
+        "reorder",
+        "relevance",
+        "ranking",
+        "promote",
+        "cross encoder"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Reranker",
+      contentHash: "sha256:9ddf9a320bef45d9bdc98a5cfb6e0f7a16465170257c150d1516678b75fd8e22",
+      structuralHash: "path:M|path:MH|path:MH|path:MH|path:MV",
+      elementCount: 5,
+      byteSize: 297,
+      related: [
+        "tokenizer"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "retriever",
+      category: "rag",
+      subcategory: "retrieval",
+      name: "Retriever",
+      description: "Component that pulls relevant documents from a store",
+      tags: [
+        "retriever",
+        "pull",
+        "fetch",
+        "attract",
+        "magnet",
+        "relevant"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Retriever",
+      contentHash: "sha256:1cfa2f4ef96aa82c287273707905589c5b11c6165605802944abc67c512c8498",
+      structuralHash: "path:MH|path:MH|path:MVAV",
+      elementCount: 3,
+      byteSize: 262,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "semantic-search",
+      category: "rag",
+      subcategory: "retrieval",
+      name: "Semantic Search",
+      description: "Finding results by meaning rather than exact words",
+      tags: [
+        "semantic search",
+        "meaning",
+        "similarity",
+        "nearest",
+        "lookup",
+        "embedding search"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "SemanticSearch",
+      contentHash: "sha256:1e3ebf74775f5901448b013c841f8eccb483fe14451e1630c0e52a0d3d0c4530",
+      structuralHash: "circle|circle|circle|path:M",
+      elementCount: 4,
+      byteSize: 310,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "source-citation",
+      category: "rag",
+      subcategory: "grounding",
+      name: "Source Citation",
+      description: "A pointer back to where an answer came from",
+      tags: [
+        "citation",
+        "quote",
+        "source",
+        "reference",
+        "attribution",
+        "provenance"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "SourceCitation",
+      contentHash: "sha256:143b8edd8e5b83098f34300b20a792028b8893bb9bf0c1d60370ce5c9811e4ff",
+      structuralHash: "path:MVAHVAZ|path:MVAHVAZ",
+      elementCount: 2,
+      byteSize: 293,
+      related: [
+        "token"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "subtask",
+      category: "agents",
+      subcategory: "planning",
+      name: "Subtask",
+      description: "A smaller piece of work nested inside a larger one",
+      tags: [
+        "subtask",
+        "nested",
+        "child",
+        "breakdown",
+        "sub step",
+        "decompose"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Subtask",
+      contentHash: "sha256:37b109b2e402191cb5398d888a0039e8fb6513de93626ad60fdd53ff90232612",
+      structuralHash: "rect|rect",
+      elementCount: 2,
+      byteSize: 286,
+      related: [
+        "context-window"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "system-prompt",
+      category: "ai",
+      subcategory: "prompt",
+      name: "System Prompt",
+      description: "Standing instructions that sit above the conversation",
+      tags: [
+        "system prompt",
+        "instruction",
+        "role",
+        "preamble",
+        "persona",
+        "rules"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "SystemPrompt",
+      contentHash: "sha256:12c7c7a064c163b60a5ea37f00d0fa17206a45497dddc16945cdc121f5ce93db",
+      structuralHash: "path:M|path:MH|path:MHLVLHLVHLVZ",
+      elementCount: 3,
+      byteSize: 287,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "temperature",
+      category: "ai",
+      subcategory: "inference",
+      name: "Temperature",
+      description: "How much randomness a model allows in its output",
+      tags: [
+        "temperature",
+        "randomness",
+        "sampling",
+        "creativity",
+        "variance",
+        "parameter"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Temperature",
+      contentHash: "sha256:655f4b39d5717f955718d815ad43fba09ba8a4d0f7ad1a3b5ed08313fe57e9f9",
+      structuralHash: "path:MV|path:MVAVA",
+      elementCount: 2,
+      byteSize: 262,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "token",
+      category: "ai",
+      subcategory: "token",
+      name: "Token",
+      description: "Continuous text split into discrete units",
+      tags: [
+        "token",
+        "split",
+        "unit",
+        "text",
+        "segment",
+        "tokenize"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Token",
+      contentHash: "sha256:662af51c91436cb0332dca87485f194e610030fbe3be621bf287fdf0b36c6ace",
+      structuralHash: "path:MH|path:MH|path:MH|path:MH",
+      elementCount: 4,
+      byteSize: 267,
+      related: [
+        "mcp-config",
+        "mcp-connection",
+        "source-citation"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "tokenizer",
+      category: "ai",
+      subcategory: "token",
+      name: "Tokenizer",
+      description: "The component that splits text into tokens",
+      tags: [
+        "tokenizer",
+        "split",
+        "encode",
+        "segment",
+        "parse",
+        "fan out"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Tokenizer",
+      contentHash: "sha256:ffc7c34f4275db1e5801941099519c6dda385f1a762f52d23c878950767d85c9",
+      structuralHash: "path:MH|path:MH|path:MH|path:MH|path:MV",
+      elementCount: 5,
+      byteSize: 285,
+      related: [
+        "reranker",
+        "inference"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "training",
+      category: "ai",
+      subcategory: "training",
+      name: "Training",
+      description: "Teaching a model from data until it improves",
+      tags: [
+        "training",
+        "learn",
+        "fit",
+        "improve",
+        "epoch",
+        "optimise"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Training",
+      contentHash: "sha256:f00d230f5ef815b4ffe085c7dd0a21e04791bdcff7573b6a1c601c6c816739b6",
+      structuralHash: "path:ML|path:MVLVZ",
+      elementCount: 2,
+      byteSize: 259,
+      related: [
+        "model",
+        "llm",
+        "guardrail"
+      ],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "vector",
+      category: "ai",
+      subcategory: "embedding",
+      name: "Vector",
+      description: "An ordered list of numbers representing meaning",
+      tags: [
+        "vector",
+        "array",
+        "column",
+        "numbers",
+        "coordinates",
+        "features"
+      ],
+      aliases: [],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "Vector",
+      contentHash: "sha256:6625688041e799a19a7bd66e84fa2d0b2ae48da900c76ddd652ff7dd5453a38b",
+      structuralHash: "circle|circle|circle|path:MHVH|path:MHVH",
+      elementCount: 5,
+      byteSize: 334,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    },
+    {
+      slug: "vector-database",
+      category: "rag",
+      subcategory: "vector",
+      name: "Vector Database",
+      description: "Database for storing and searching vectors",
+      tags: [
+        "vector",
+        "database",
+        "store",
+        "embedding",
+        "index",
+        "similarity"
+      ],
+      aliases: [
+        "vector-store"
+      ],
+      keywords: [],
+      contributors: [],
+      deprecated: null,
+      componentName: "VectorDatabase",
+      contentHash: "sha256:3249ab09fa2c35700b2d1c061d507ba52e78b7d88fc38de97c3431b40f8291a7",
+      structuralHash: "ellipse|path:MH|path:MH|path:MH|path:MVCSV",
+      elementCount: 5,
+      byteSize: 360,
+      related: [],
+      addedIn: "0.1.0",
+      updatedIn: "0.1.0"
+    }
+  ]
+};
+
+// ../shared/src/search.ts
+var FOCUS = /* @__PURE__ */ new Set(["ai", "agents", "mcp", "rag"]);
+var normalizeQuery = (q) => q.trim().toLowerCase().replace(/[\s_]+/g, "-");
+function scoreOne(i, q) {
+  const name = i.name.toLowerCase();
+  const aliases = i.aliases ?? [];
+  if (i.slug === q) return { score: 1e3, matched: "exact name" };
+  if (aliases.includes(q)) return { score: 900, matched: "exact alias" };
+  if (i.slug.startsWith(q)) return { score: 800 - i.slug.length * 2, matched: "name starts with" };
+  if (name.startsWith(q)) return { score: 700 - name.length * 2, matched: "name starts with" };
+  if (i.slug.split("-").some((w) => w.startsWith(q))) return { score: 600, matched: "word in name" };
+  const exactTag = i.tags.find((t) => t === q);
+  if (exactTag) return { score: 500, matched: `tag \u201C${exactTag}\u201D` };
+  const prefixTag = i.tags.find((t) => t.startsWith(q));
+  if (prefixTag) return { score: 400, matched: `tag \u201C${prefixTag}\u201D` };
+  if (name.includes(q) || i.slug.includes(q)) return { score: 300, matched: "name contains" };
+  const looseTag = i.tags.find((t) => t.includes(q));
+  if (looseTag) return { score: 200, matched: `tag \u201C${looseTag}\u201D` };
+  if (i.description.toLowerCase().includes(q)) return { score: 120, matched: "description" };
+  return { score: 0, matched: "" };
+}
+function searchIcons(icons2, query, opts = {}) {
+  const q = normalizeQuery(query);
+  const pool = opts.category ? icons2.filter((i) => i.category === opts.category) : icons2;
+  if (!q) return [];
+  const words = q.split("-").filter(Boolean);
+  const hits = [];
+  for (const icon of pool) {
+    const whole = scoreOne(icon, q);
+    let score = whole.score;
+    let matched = whole.matched;
+    if (!score && words.length > 1) {
+      const parts = words.map((w) => scoreOne(icon, w));
+      if (parts.every((p) => p.score > 0)) {
+        score = Math.round(parts.reduce((a, p) => a + p.score, 0) / words.length);
+        matched = `all terms \u2014 ${parts[0].matched}`;
+      }
+    }
+    if (!score) continue;
+    if (FOCUS.has(icon.category)) score += 50;
+    score -= Math.round(icon.slug.length / 4);
+    hits.push({ icon, score, matched });
+  }
+  hits.sort((a, b) => b.score - a.score || a.icon.slug.localeCompare(b.icon.slug));
+  return opts.limit ? hits.slice(0, opts.limit) : hits;
+}
+function editDistance(a, b, cap = 4) {
+  if (Math.abs(a.length - b.length) > cap) return cap + 1;
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const cur = [i];
+    for (let j = 1; j <= b.length; j++)
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    prev = cur;
+  }
+  return prev[b.length];
+}
+function suggest(icons2, query, limit = 6) {
+  const q = normalizeQuery(query);
+  if (q.length < 3) return [];
+  return icons2.map((i) => ({ i, d: Math.min(editDistance(q, i.slug), ...i.tags.map((t) => editDistance(q, t))) })).filter((x) => x.d <= 3).sort((a, b) => a.d - b.d).slice(0, limit).map((x) => x.i);
+}
+
+// src/data.ts
+var version = metadata_default.version;
+var icons = metadata_default.icons;
+var categories = metadata_default.categories;
+var bySlug = new Map(icons.map((i) => [i.slug, i]));
+for (const i of icons) for (const a of i.aliases ?? []) bySlug.set(a, i);
+var find = (slug) => bySlug.get(slug.trim().toLowerCase());
+var search = (q, o) => searchIcons(icons, q, o);
+var nearest = (q) => suggest(icons, q);
+var inCategory = (c, sub) => icons.filter((i) => i.category === c && (!sub || i.subcategory === sub));
+function snippets(icon, size = 24) {
+  return {
+    import: `import { ${icon.componentName} } from "@iconmind/react";`,
+    react: size === 24 ? `<${icon.componentName} />` : `<${icon.componentName} size={${size}} />`,
+    html: `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><use href="sprite.svg#im-${icon.slug}"/></svg>`
+  };
+}
+
+// src/resources.ts
+function registerResources(server2) {
+  server2.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: [
+      { uri: "category://index", name: "Categories", description: "Every category with its counts", mimeType: "application/json" },
+      { uri: "metadata://stats", name: "Set statistics", description: "Version and coverage", mimeType: "application/json" },
+      ...categories.map((c) => ({
+        uri: `category://${c.slug}`,
+        name: `${c.name} icons`,
+        description: `${c.count} icons in ${c.slug}`,
+        mimeType: "application/json"
+      }))
+      // metadata://all is readable but deliberately not advertised: it is large enough
+      // to crowd out a context window, and search_icon answers the same questions.
+    ]
+  }));
+  server2.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+    const uri = req.params.uri;
+    const body = (data) => ({
+      contents: [{ uri, mimeType: "application/json", text: JSON.stringify(data, null, 2) }]
+    });
+    if (uri === "category://index") return body(categories);
+    if (uri === "metadata://stats") {
+      return body({
+        version,
+        total: icons.length,
+        byCategory: Object.fromEntries(categories.map((c) => [c.slug, c.count]))
+      });
+    }
+    if (uri === "metadata://all") return body({ version, icons });
+    const cat = /^category:\/\/(.+)$/.exec(uri);
+    if (cat) return body(inCategory(cat[1]));
+    const meta = /^icon:\/\/(.+)\/meta$/.exec(uri);
+    if (meta) {
+      const icon = find(meta[1]);
+      if (!icon) throw new Error(`No icon '${meta[1]}'`);
+      return body(icon);
+    }
+    const one = /^icon:\/\/(.+)$/.exec(uri);
+    if (one) {
+      const icon = find(one[1]);
+      if (!icon) throw new Error(`No icon '${one[1]}'`);
+      return body(icon);
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+  });
+}
+
+// src/tools.ts
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+var CATEGORY_ENUM = categories.map((c) => c.slug);
+var TOOLS = [
+  {
+    name: "search_icon",
+    description: "Search IconMind icons by keyword, concept, or description. Use this before writing any UI code that needs an icon, so you pick one that actually exists instead of guessing a name.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Keyword or concept, e.g. 'vector database', 'agent memory'" },
+        category: { type: "string", enum: CATEGORY_ENUM, description: "Restrict to one domain" },
+        limit: { type: "integer", default: 10, maximum: 50 }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "get_icon",
+    description: "Fetch one icon by its exact slug: metadata plus paste-ready React and HTML.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        slug: { type: "string" },
+        size: { type: "integer", default: 24 }
+      },
+      required: ["slug"]
+    }
+  },
+  {
+    name: "list_category",
+    description: "List icons in a category, optionally filtered by subcategory. With no arguments, returns the categories themselves.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        category: { type: "string", enum: CATEGORY_ENUM },
+        subcategory: { type: "string" },
+        limit: { type: "integer", default: 50, maximum: 200 }
+      }
+    }
+  },
+  {
+    name: "get_icon_code",
+    description: "Generate one combined import plus usage for several icons at once. Prefer this over repeated get_icon calls when building a component that needs more than one.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        slugs: { type: "array", items: { type: "string" }, maxItems: 20 },
+        framework: { type: "string", enum: ["react", "html"], default: "react" }
+      },
+      required: ["slugs"]
+    }
+  }
+];
+var json = (data) => ({ content: [{ type: "text", text: JSON.stringify(data, null, 2) }] });
+function registerTools(server2) {
+  server2.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+  server2.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const a = req.params.arguments ?? {};
+    switch (req.params.name) {
+      case "search_icon": {
+        const query = String(a["query"] ?? "");
+        const hits = search(query, {
+          category: a["category"] ? String(a["category"]) : void 0,
+          limit: Number(a["limit"] ?? 10)
+        });
+        if (!hits.length) {
+          return json({
+            query,
+            count: 0,
+            suggestions: nearest(query).map((i) => i.slug),
+            hint: "Nothing matched. Try a broader term, or say so rather than inventing an icon name."
+          });
+        }
+        return json({
+          query,
+          count: hits.length,
+          results: hits.map(({ icon, score, matched }) => ({
+            slug: icon.slug,
+            name: icon.name,
+            category: icon.category,
+            description: icon.description,
+            score,
+            matched,
+            ...snippets(icon)
+          }))
+        });
+      }
+      case "get_icon": {
+        const slug = String(a["slug"] ?? "");
+        const icon = find(slug);
+        if (!icon) {
+          return json({
+            found: false,
+            slug,
+            suggestions: nearest(slug).map((i) => i.slug),
+            hint: "Slug not found. Use search_icon for a free-text search."
+          });
+        }
+        return json({
+          found: true,
+          ...icon,
+          ...snippets(icon, Number(a["size"] ?? 24))
+        });
+      }
+      case "list_category": {
+        const category = a["category"] ? String(a["category"]) : void 0;
+        if (!category) {
+          return json({
+            categories: categories.map((c) => ({
+              slug: c.slug,
+              name: c.name,
+              count: c.count,
+              subcategories: c.subcategories.map((s) => s.slug)
+            }))
+          });
+        }
+        const sub = a["subcategory"] ? String(a["subcategory"]) : void 0;
+        const list = inCategory(category, sub).slice(0, Number(a["limit"] ?? 50));
+        return json({
+          category,
+          subcategory: sub,
+          count: list.length,
+          icons: list.map((i) => ({
+            slug: i.slug,
+            name: i.name,
+            subcategory: i.subcategory,
+            description: i.description
+          }))
+        });
+      }
+      case "get_icon_code": {
+        const slugs = a["slugs"] ?? [];
+        const found = slugs.map((s) => ({ slug: s, icon: find(s) }));
+        const missing = found.filter((f) => !f.icon).map((f) => f.slug);
+        const ok = found.flatMap((f) => f.icon ? [f.icon] : []);
+        if (!ok.length) return json({ missing, hint: "None of those slugs exist. Use search_icon." });
+        const framework = String(a["framework"] ?? "react");
+        if (framework === "html") {
+          return json({ missing, html: ok.map((i) => snippets(i).html).join("\n") });
+        }
+        return json({
+          missing,
+          import: `import { ${ok.map((i) => i.componentName).join(", ")} } from "@iconmind/react";`,
+          usage: ok.map((i) => `<${i.componentName} />`).join("\n")
+        });
+      }
+      default:
+        return json({ error: `Unknown tool: ${req.params.name}` });
+    }
+  });
+}
+
+// src/prompts.ts
+import { GetPromptRequestSchema, ListPromptsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+var PROMPTS = [
+  {
+    name: "recommend_icons",
+    description: "Recommend icons for a feature or UI screen",
+    arguments: [
+      { name: "description", description: "The feature or screen being built", required: true },
+      { name: "framework", description: "react or html", required: false }
+    ]
+  },
+  {
+    name: "ai_workflow_icons",
+    description: "Map icons onto each stage of an AI, agent, or RAG pipeline",
+    arguments: [{ name: "workflow", description: "The pipeline, e.g. 'RAG with reranking'", required: true }]
+  }
+];
+var TEXT = {
+  recommend_icons: (a) => `I am building: ${a["description"] ?? ""}
+
+Use the search_icon tool to find the right IconMind icon for every UI element that needs
+one. For each recommendation, state:
+1. Which UI element it is for
+2. The icon slug you chose
+3. Why that icon is semantically right, not merely visually similar
+
+Do not invent icon names. If search_icon finds nothing suitable, say so and suggest the
+closest icon that actually exists.
+
+Framework: ${a["framework"] ?? "react"}`,
+  ai_workflow_icons: (a) => `Pipeline to visualize: ${a["workflow"] ?? ""}
+
+1. Break this pipeline into its distinct stages.
+2. For each stage, use search_icon (prefer the ai, agents, mcp, and rag categories) to
+   find the most semantically accurate icon.
+3. Return a table: Stage | Icon slug | Why.
+4. Finally, produce one combined import block via get_icon_code.
+
+Favour meaning over visual uniformity \u2014 an icon with the wrong meaning costs more than
+one that merely looks slightly out of place.`
+};
+function registerPrompts(server2) {
+  server2.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: PROMPTS }));
+  server2.setRequestHandler(GetPromptRequestSchema, async (req) => {
+    const build = TEXT[req.params.name];
+    if (!build) throw new Error(`Unknown prompt: ${req.params.name}`);
+    return {
+      messages: [{
+        role: "user",
+        content: { type: "text", text: build(req.params.arguments ?? {}) }
+      }]
+    };
+  });
+}
+
+// src/index.ts
+var server = new Server(
+  { name: "iconmind", version },
+  { capabilities: { resources: {}, tools: {}, prompts: {} } }
+);
+registerResources(server);
+registerTools(server);
+registerPrompts(server);
+await server.connect(new StdioServerTransport());