nicepick-mcp 1.0.0

package/README.md

@@ -0,0 +1,39 @@
+# NicePick MCP — the verdict layer for AI agents
+
+Your docs tool (Context7) tells an agent how to use the library it *already chose*.
+**NicePick tells it which one to choose.**
+
+900+ structured, opinionated tool/library/framework comparisons. No hedging — every
+query returns a winner and a decisive reason. Backed by [nicepick.dev](https://nicepick.dev).
+
+## Tools
+
+- **`compare_tools(tool_a, tool_b)`** — head-to-head verdict. `postgresql` vs `mysql`,
+  `react` vs `svelte`, `vite` vs `webpack`. Returns the pick, why, and when to use each.
+- **`recommend_tool(query)`** — best pick for a use-case. `"best vector database"`,
+  `"best python web framework"`.
+
+## Install (Claude Desktop / Cursor / any MCP client)
+
+```json
+{
+  "mcpServers": {
+    "nicepick": {
+      "command": "npx",
+      "args": ["-y", "nicepick-mcp"]
+    }
+  }
+}
+```
+
+Or run directly: `node index.mjs` (talks MCP over stdio).
+
+## Why
+
+LLMs hallucinate non-existent packages in ~20% of generated code. Picking the *right*
+real tool is a decision they're bad at and there's no current source for — registries
+rank by popularity, docs assume you've chosen, and chat is un-opinionated. NicePick is
+the structured, opinionated verdict — the one shape a model can't reliably produce from
+training data.
+
+MIT. No API key required.

package/index.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+// NicePick MCP server — the opinionated "which tool should I pick?" decision layer
+// for AI agents. Context7 (57.8k stars) owns docs-for-a-library-you-already-chose;
+// NOBODY owns the verdict ("X vs Y — pick X because…"). NicePick has 900 structured
+// opinionated comparisons + taxonomy — exactly the corpus an LLM can't reliably
+// produce from training data (it hallucinates dead packages ~20% of the time).
+//
+// Tools exposed:
+//   compare_tools(a, b)      → Nice Pick's verdict on a head-to-head
+//   recommend_tool(query)    → best pick for a use-case / category
+//
+// Backed by the live public API at nicepick.dev/api/recommend (CORS, no key needed).
+// Distribute via the MCP registry + Smithery/Glama/PulseMCP. Install:
+//   npx @nicepick/mcp     (once published)  or run this file directly with node.
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+const BASE = process.env.NICEPICK_API || "https://nicepick.dev";
+
+async function api(path) {
+  const res = await fetch(`${BASE}${path}`, {
+    headers: { "user-agent": "nicepick-mcp/1.0" },
+  });
+  if (!res.ok) throw new Error(`NicePick API ${res.status}`);
+  return res.json();
+}
+
+const server = new Server(
+  { name: "nicepick", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "compare_tools",
+      description:
+        "Get Nice Pick's opinionated verdict on two tools/libraries/frameworks head-to-head (e.g. 'postgres' vs 'mysql', 'react' vs 'svelte'). Returns the winner, a decisive reason, and when to use each. Use this when an agent or user must choose between two specific options and wants a real verdict, not a hedge.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          tool_a: { type: "string", description: "First tool/library/framework (e.g. 'postgresql')" },
+          tool_b: { type: "string", description: "Second tool/library/framework (e.g. 'mysql')" },
+        },
+        required: ["tool_a", "tool_b"],
+      },
+    },
+    {
+      name: "recommend_tool",
+      description:
+        "Get Nice Pick's recommendation for a use-case or category (e.g. 'best react state management', 'best vector database', 'best python web framework'). Returns the top pick plus ranked alternatives with a decisive rationale.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "The use-case or 'best X' query" },
+        },
+        required: ["query"],
+      },
+    },
+  ],
+}));
+
+function fmtComparison(d) {
+  let out = `## Nice Pick: ${d.pick} wins (${d.title})\n\n`;
+  if (d.nice_says) out += `**Verdict:** ${d.nice_says}\n\n`;
+  if (d.pick_reason) out += `${d.pick_reason}\n\n`;
+  if (d.verdict) {
+    if (d.verdict.useTool1If) out += `- Use **${d.tool1?.name || "the first"}** if: ${d.verdict.useTool1If}\n`;
+    if (d.verdict.useTool2If) out += `- Use **${d.tool2?.name || "the second"}** if: ${d.verdict.useTool2If}\n`;
+  }
+  out += `\n— ${BASE}/compare/${d.slug || ""}`;
+  return out;
+}
+
+function fmtRecommendation(d) {
+  let out = `## Nice Pick: ${d.pick}\n\n`;
+  if (d.nice_says) out += `${d.nice_says}\n\n`;
+  if (Array.isArray(d.tools) && d.tools.length) {
+    out += `Ranked:\n`;
+    for (const t of d.tools.slice(0, 5)) {
+      out += `${t.rank}. **${t.name}**${t.tagline ? ` — ${t.tagline}` : ""}\n`;
+    }
+  }
+  return out;
+}
+
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const { name, arguments: args } = req.params;
+  try {
+    if (name === "compare_tools") {
+      const a = encodeURIComponent(args.tool_a.toLowerCase().trim());
+      const b = encodeURIComponent(args.tool_b.toLowerCase().trim());
+      const d = await api(`/api/recommend?a=${a}&b=${b}`);
+      const text =
+        d.type === "comparison"
+          ? fmtComparison(d)
+          : `Nice Pick doesn't have a head-to-head on those two yet. Closest: ${JSON.stringify(d).slice(0, 200)}`;
+      return { content: [{ type: "text", text }] };
+    }
+    if (name === "recommend_tool") {
+      const q = encodeURIComponent(args.query.trim());
+      const d = await api(`/api/recommend?q=${q}`);
+      const text =
+        d.type === "comparison" ? fmtComparison(d) : fmtRecommendation(d);
+      return { content: [{ type: "text", text }] };
+    }
+    return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+  } catch (e) {
+    return { content: [{ type: "text", text: `NicePick error: ${e.message}` }], isError: true };
+  }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("NicePick MCP server running (stdio)");

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "nicepick-mcp",
+  "version": "1.0.0",
+  "description": "Opinionated 'which tool should I pick?' verdicts for AI agents — the decision layer next to your docs. 900+ structured tool/library/framework comparisons.",
+  "type": "module",
+  "bin": {
+    "nicepick-mcp": "index.mjs"
+  },
+  "main": "index.mjs",
+  "files": ["index.mjs", "README.md"],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai-agents",
+    "tool-comparison",
+    "tech-stack",
+    "developer-tools",
+    "claude",
+    "cursor"
+  ],
+  "engines": { "node": ">=18" },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "license": "MIT",
+  "homepage": "https://nicepick.dev"
+}