tooldirectory-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tool Directory (tooldirectory.ai)
+
+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,83 @@
+# Tool Directory MCP Server
+
+MCP server for the [AI Tool Directory](https://tooldirectory.ai) — a live, human-edited catalog of 2,000+ AI tools. Lets any MCP client (Claude Desktop, Claude Code, Cursor, Windsurf, agent frameworks) query the catalog mid-task instead of guessing from a frozen training cut.
+
+The headline tool is **`check_tool_status`**: whether an AI tool is still alive. It's the one fact LLMs reliably get wrong — models keep recommending products that shut down months ago. This server answers it from the directory's [AI Graveyard](https://tooldirectory.ai/graveyard), a maintained dataset of 150+ defunct and acquired AI tools, and suggests live alternatives when a tool is dead.
+
+## Tools
+
+| Tool | What it does |
+| --- | --- |
+| `search_tools` | Hybrid semantic search across the catalog — by keyword, use case, or category. |
+| `get_tool` | Full profile of one tool: pricing, features, editorial verdict, last human-verified date. |
+| `check_tool_status` | Is this tool active, deceased, or acquired? Date + cause if it shut down, plus live alternatives. |
+| `find_alternatives` | Curated alternatives to a tool; live replacements if it's defunct. |
+| `compare_tools` | Side-by-side comparison of two tools, with the editor's head-to-head verdict when one exists. |
+| `list_tools` | Top-rated active tools for a category or job role, optionally filtered by pricing. |
+
+Read-only, no API key, no signup.
+
+## Install
+
+### Hosted endpoint (no install)
+
+The server is also available as a remote MCP (Streamable HTTP) — point your client at:
+
+```
+https://tooldirectory.ai/api/mcp
+```
+
+### Claude Desktop / Claude Code
+
+```json
+{
+  "mcpServers": {
+    "tooldirectory": {
+      "command": "npx",
+      "args": ["-y", "tooldirectory-mcp"]
+    }
+  }
+}
+```
+
+Or with Claude Code:
+
+```bash
+claude mcp add tooldirectory -- npx -y tooldirectory-mcp
+```
+
+### Cursor / Windsurf / other MCP clients
+
+Use the same stdio command: `npx -y tooldirectory-mcp`.
+
+### Docker
+
+```bash
+docker build -t tooldirectory-mcp .
+docker run -i tooldirectory-mcp
+```
+
+## Example prompts
+
+- *"Is Jasper still operating? What happened to Inflection Pi?"*
+- *"Find me alternatives to Midjourney with a free tier."*
+- *"Compare Gamma and Beautiful.ai for making decks."*
+- *"What are the best AI tools for sales teams?"*
+
+## How it works
+
+This package is a thin stdio front-end over the canonical hosted endpoint at `tooldirectory.ai/api/mcp`, where the search (Meilisearch hybrid semantic) and catalog logic live. Tool schemas are declared locally, so `initialize` and `tools/list` respond instantly with no network call; `tools/call` proxies to the hosted endpoint. Zero runtime dependencies.
+
+Set `TOOLDIRECTORY_MCP_ENDPOINT` to override the upstream endpoint (e.g. for testing).
+
+## About the data
+
+The catalog is maintained by [Tool Directory](https://tooldirectory.ai) — an AI tool company run by humans that use AI. Every listed tool has a lifecycle status; editorial reviews carry a named editor and a last-verified date. Related machine-readable surfaces:
+
+- [Research hub](https://tooldirectory.ai/research) — AI tool mortality statistics
+- [Catalog feed](https://tooldirectory.ai/feed/catalog.json) / [Graveyard feed](https://tooldirectory.ai/feed/graveyard.json)
+- [/mcp](https://tooldirectory.ai/mcp) — server documentation page
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "tooldirectory-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for the AI Tool Directory — search 2,000+ AI tools, compare them, find alternatives, and check whether a tool is still active, defunct, or acquired.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mcp-server",
+    "ai-tools",
+    "ai-tool-directory",
+    "ai-graveyard",
+    "claude",
+    "agents"
+  ],
+  "homepage": "https://tooldirectory.ai/mcp",
+  "bugs": {
+    "url": "https://github.com/AI-Directory-Partners/tooldirectory-mcp/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AI-Directory-Partners/tooldirectory-mcp.git"
+  },
+  "license": "MIT",
+  "author": "Tool Directory (https://tooldirectory.ai)",
+  "type": "module",
+  "bin": {
+    "tooldirectory-mcp": "src/index.js"
+  },
+  "files": [
+    "src/"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/index.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+/**
+ * tooldirectory-mcp — stdio MCP server for the AI Tool Directory catalog
+ * (https://tooldirectory.ai).
+ *
+ * Lets any MCP client (Claude Desktop, Cursor, Windsurf, agent frameworks)
+ * query a live catalog of 2,000+ AI tools mid-task instead of guessing from a
+ * frozen training cut. The headline capability is `check_tool_status` —
+ * whether a tool is still alive — the one fact LLMs reliably get wrong and
+ * the AI Graveyard dataset uniquely answers.
+ *
+ * Design: thin stdio front-end over the canonical hosted MCP endpoint at
+ * https://tooldirectory.ai/api/mcp. Tool schemas are declared locally so
+ * `initialize` and `tools/list` answer instantly with no network; `tools/call`
+ * proxies to the hosted endpoint where the real search/catalog logic lives.
+ * Zero runtime dependencies — the stdio protocol surface is small (newline-
+ * delimited JSON-RPC 2.0) and Node 18+ ships fetch.
+ *
+ * Prefer a remote server? Point your client straight at
+ * https://tooldirectory.ai/api/mcp (Streamable HTTP) and skip this package.
+ */
+
+const ENDPOINT = process.env.TOOLDIRECTORY_MCP_ENDPOINT || 'https://tooldirectory.ai/api/mcp';
+const PROTOCOL_VERSION = '2025-06-18';
+const SERVER_NAME = 'tooldirectory-ai';
+const SERVER_VERSION = '1.0.0';
+const CALL_TIMEOUT_MS = 30_000;
+
+// ---------------------------------------------------------------------------
+// Tool definitions — kept in lockstep with the hosted endpoint's tools/list.
+// Declared locally so introspection works offline and instantly.
+// ---------------------------------------------------------------------------
+
+const TOOLS = [
+  {
+    name: 'search_tools',
+    description:
+      'Search the AI Tool Directory catalog (2,000+ AI tools) by keyword, use case, or category using hybrid semantic search. Returns ranked tools with slug, one-line description, pricing model, and rating. Use this to discover tools, then get_tool for full detail.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description:
+            'What the user is looking for, e.g. "AI video editing" or "alternatives to Jasper".'
+        },
+        limit: {
+          type: 'integer',
+          description: 'Max results (1-20, default 8).'
+        }
+      },
+      required: ['query']
+    }
+  },
+  {
+    name: 'get_tool',
+    description:
+      'Get the full profile of one AI tool by its directory slug: description, pricing, key features, editorial verdict and rating, the date it was last human-verified, lifecycle status, and the official site URL.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        slug: {
+          type: 'string',
+          description:
+            'The directory slug, e.g. "gamma-app-ai-powered-presenting-ideas" (from search_tools).'
+        }
+      },
+      required: ['slug']
+    }
+  },
+  {
+    name: 'check_tool_status',
+    description:
+      'Check whether an AI tool is still alive. Returns active, deceased, or acquired — with the date and cause if it shut down, and live alternatives if it did. Use this before recommending a tool to avoid suggesting one that no longer exists.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        tool: {
+          type: 'string',
+          description:
+            'Tool name or directory slug to check, e.g. "Jasper" or "jasper-ai".'
+        }
+      },
+      required: ['tool']
+    }
+  },
+  {
+    name: 'find_alternatives',
+    description:
+      'Find curated alternatives to a given AI tool by its directory slug. If the tool has shut down, returns live replacements. Good for "what should I use instead of X" questions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        slug: {
+          type: 'string',
+          description: 'The directory slug of the tool to find alternatives for.'
+        }
+      },
+      required: ['slug']
+    }
+  },
+  {
+    name: 'compare_tools',
+    description:
+      'Compare two AI tools side by side by their directory slugs. Returns each tool’s profile (pricing, rating, editorial verdict, lifecycle) plus the editor’s head-to-head verdict and bottom line when one exists for the pair.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        slugA: {
+          type: 'string',
+          description: 'Directory slug of the first tool.'
+        },
+        slugB: {
+          type: 'string',
+          description: 'Directory slug of the second tool.'
+        }
+      },
+      required: ['slugA', 'slugB']
+    }
+  },
+  {
+    name: 'list_tools',
+    description:
+      'List the top-rated active AI tools in a category or for a job role, optionally filtered by pricing. Good for "what are the best AI tools for sales" or "free tools in <category>".',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        category: {
+          type: 'string',
+          description:
+            'Category slug (from search_tools results), e.g. "productivity".'
+        },
+        role: {
+          type: 'string',
+          description: 'Job-role slug, e.g. "sales", "marketing", "customer-support".'
+        },
+        pricing: {
+          type: 'string',
+          description: 'Optional pricing filter: Free, Freemium, Free Trial, or Paid.'
+        },
+        limit: {
+          type: 'integer',
+          description: 'Max results (1-20, default 8).'
+        }
+      }
+    }
+  }
+];
+
+// ---------------------------------------------------------------------------
+// Upstream proxy — tools/call is forwarded to the hosted endpoint.
+// ---------------------------------------------------------------------------
+
+async function proxyToolCall(id, params) {
+  try {
+    const res = await fetch(ENDPOINT, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ jsonrpc: '2.0', id, method: 'tools/call', params }),
+      signal: AbortSignal.timeout(CALL_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      return rpcResult(id, {
+        content: [{ type: 'text', text: `Upstream error: HTTP ${res.status} from ${ENDPOINT}` }],
+        isError: true
+      });
+    }
+    const json = await res.json();
+    if (json && typeof json === 'object' && 'result' in json) {
+      return rpcResult(id, json.result);
+    }
+    if (json && typeof json === 'object' && 'error' in json) {
+      return { jsonrpc: '2.0', id, error: json.error };
+    }
+    return rpcResult(id, {
+      content: [{ type: 'text', text: 'Upstream returned an unexpected response shape.' }],
+      isError: true
+    });
+  } catch (err) {
+    const message = err && err.name === 'TimeoutError' ? 'Upstream request timed out.' : `Upstream request failed: ${err?.message ?? 'unknown error'}`;
+    return rpcResult(id, {
+      content: [{ type: 'text', text: message }],
+      isError: true
+    });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// JSON-RPC 2.0 over stdio (newline-delimited)
+// ---------------------------------------------------------------------------
+
+function rpcResult(id, result) {
+  return { jsonrpc: '2.0', id, result };
+}
+
+function rpcError(id, code, message) {
+  return { jsonrpc: '2.0', id, error: { code, message } };
+}
+
+async function handleMessage(msg) {
+  if (!msg || typeof msg !== 'object') return rpcError(null, -32600, 'Invalid Request');
+  const id = msg.id ?? null;
+  const method = msg.method;
+
+  // Notifications: no response.
+  if (typeof method === 'string' && method.startsWith('notifications/')) return null;
+
+  switch (method) {
+    case 'initialize': {
+      const requested = msg.params?.protocolVersion;
+      return rpcResult(id, {
+        protocolVersion: typeof requested === 'string' ? requested : PROTOCOL_VERSION,
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
+        instructions:
+          'Read-only access to the AI Tool Directory catalog. Use check_tool_status before recommending a tool to confirm it still exists.'
+      });
+    }
+    case 'ping':
+      return rpcResult(id, {});
+    case 'tools/list':
+      return rpcResult(id, { tools: TOOLS });
+    case 'tools/call': {
+      const params = msg.params ?? {};
+      const known = TOOLS.some((t) => t.name === params.name);
+      if (!known) {
+        return rpcResult(id, {
+          content: [{ type: 'text', text: `Unknown tool: ${String(params.name)}` }],
+          isError: true
+        });
+      }
+      return proxyToolCall(id, params);
+    }
+    default:
+      return rpcError(id, -32601, `Method not found: ${String(method)}`);
+  }
+}
+
+function send(response) {
+  if (response) process.stdout.write(JSON.stringify(response) + '\n');
+}
+
+// Exit only after stdin has closed AND all in-flight requests have answered —
+// otherwise a one-shot pipe (or a clean client shutdown) kills pending
+// tools/call fetches before their responses flush.
+let pending = 0;
+let stdinClosed = false;
+
+function maybeExit() {
+  if (stdinClosed && pending === 0) process.exit(0);
+}
+
+let buffer = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+  buffer += chunk;
+  let newline;
+  while ((newline = buffer.indexOf('\n')) !== -1) {
+    const line = buffer.slice(0, newline).trim();
+    buffer = buffer.slice(newline + 1);
+    if (!line) continue;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      send(rpcError(null, -32700, 'Parse error'));
+      continue;
+    }
+    pending += 1;
+    handleMessage(msg)
+      .then(send)
+      .catch((err) => {
+        process.stderr.write(`[tooldirectory-mcp] handler error: ${err?.message}\n`);
+        send(rpcError(msg?.id ?? null, -32603, 'Internal error'));
+      })
+      .finally(() => {
+        pending -= 1;
+        maybeExit();
+      });
+  }
+});
+process.stdin.on('end', () => {
+  stdinClosed = true;
+  maybeExit();
+});
+
+process.stderr.write(`[tooldirectory-mcp] v${SERVER_VERSION} ready (stdio) → ${ENDPOINT}\n`);