@unfragile/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,93 @@
+# @unfragile/mcp-server
+
+Query the [Unfragile match graph](https://unfragile.ai) from any AI agent. Find AI tools, assemble harness stacks, compare artifacts — every query feeds the graph.
+
+## Install
+
+### Claude Code
+
+```bash
+claude mcp add unfragile -- npx -y @unfragile/mcp-server
+```
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "unfragile": {
+      "command": "npx",
+      "args": ["-y", "@unfragile/mcp-server"]
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "unfragile": {
+      "command": "npx",
+      "args": ["-y", "@unfragile/mcp-server"]
+    }
+  }
+}
+```
+
+### Windsurf
+
+Add to `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "unfragile": {
+      "command": "npx",
+      "args": ["-y", "@unfragile/mcp-server"]
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `search` | Find AI tools by intent. "best framework for building AI agents" |
+| `find_mcps` | Discover MCP servers by capability. "Postgres + Slack integration" |
+| `get_artifact` | Get full details + capabilities for a specific artifact |
+| `compare` | Compare two artifacts side-by-side |
+| `find_stack` | Assemble a complete harness stack for a use case |
+
+## Examples
+
+Once installed, ask your agent:
+
+- "Find me MCP servers for Postgres and Slack"
+- "What's the best framework for building AI agents?"
+- "Compare LangChain vs CrewAI"
+- "I'm building a customer support agent — what tools do I need?"
+- "Get details on Cursor's capabilities"
+
+## How it works
+
+The MCP server calls the [Unfragile API](https://unfragile.ai/api/v1/search) under the hood. Every query becomes a match record in the graph — the graph learns from every interaction, regardless of where it happens.
+
+10,000+ AI artifacts. 33,000+ capabilities. The match graph for AI.
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `UNFRAGILE_API_URL` | API base URL | `https://unfragile.ai` |
+| `UNFRAGILE_API_KEY` | API key for higher rate limits | (none) |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+// ─────────────────────────────────────────────────────────────
+// Unfragile MCP Server
+//
+// Query the match graph for AI from any agent (Claude Code,
+// Cursor, Windsurf, etc). Every query feeds the graph —
+// the graph learns from every interaction.
+//
+// Tools:
+//   search         — Find AI tools by intent/query
+//   find_mcps      — Discover MCP servers by capability need
+//   get_artifact   — Get full details + capabilities for an artifact
+//   compare        — Compare two artifacts side-by-side
+//   find_stack     — Assemble a complete harness stack for a use case
+//   feedback       — Report success/failure to close the learning loop
+// ─────────────────────────────────────────────────────────────
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+const API_BASE = process.env.UNFRAGILE_API_URL || "https://unfragile.ai";
+const API_KEY = process.env.UNFRAGILE_API_KEY || "";
+const SOURCE = "mcp-server";
+function log(tool, query) {
+    console.error(`[unfragile] ${tool}: ${query}`);
+}
+async function searchAPI(query, options = {}) {
+    const params = new URLSearchParams({ q: query, source: SOURCE });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    if (options.type)
+        params.set("type", options.type);
+    const headers = { Accept: "application/json" };
+    if (API_KEY)
+        headers["X-API-Key"] = API_KEY;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10_000);
+    try {
+        const res = await fetch(`${API_BASE}/api/v1/search?${params}`, {
+            headers,
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Unfragile API error ${res.status}: ${text}`);
+        }
+        const contentType = res.headers.get("content-type") || "";
+        if (!contentType.includes("application/json")) {
+            throw new Error(`Unfragile API returned ${contentType} instead of JSON. The API may be down or returning an error page.`);
+        }
+        return res.json();
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+// ─── Formatters ──────────────────────────────────────────────
+function formatMatch(m, rank) {
+    const lines = [];
+    const verified = m.artifact.verified ? " ✓" : "";
+    const pricing = m.artifact.pricing.free ? "Free" : m.artifact.pricing.model;
+    lines.push(`### ${rank}. ${m.artifact.name}${verified}`);
+    lines.push(`**Type:** ${m.artifact.type} | **Score:** ${m.compositeScore}/100 | **Rank:** ${m.artifact.unfragileRank}/100 | **Pricing:** ${pricing}`);
+    lines.push(`**URL:** ${m.artifact.url}`);
+    if (m.artifact.description)
+        lines.push(`\n${m.artifact.description}`);
+    if (m.capabilities.length > 0) {
+        lines.push("\n**Matched Capabilities:**");
+        for (const cap of m.capabilities) {
+            lines.push(`- **${cap.name}** (${Math.round(cap.matchScore * 100)}% match)`);
+            if (cap.description)
+                lines.push(`  ${cap.description.slice(0, 200)}`);
+            if (cap.bestFor.length > 0)
+                lines.push(`  Best for: ${cap.bestFor.join(", ")}`);
+            if (cap.limitations.length > 0)
+                lines.push(`  Limitations: ${cap.limitations.join(", ")}`);
+        }
+    }
+    if (m.matchGraph.timesMatched > 0) {
+        lines.push(`\n**Graph Signal:** Matched ${m.matchGraph.timesMatched} times | ${Math.round(m.matchGraph.successRate * 100)}% success`);
+    }
+    lines.push(`\n→ Details: ${m.artifact.pageUrl}`);
+    return lines.join("\n");
+}
+function formatResults(data) {
+    const lines = [];
+    lines.push(`# Search: "${data.query}"`);
+    lines.push(`Intent: ${data.intent.type} | Category: ${data.intent.category || "general"}`);
+    lines.push(`Found: ${data.matchCount} matches\n`);
+    if (data.matches.length === 0) {
+        lines.push("No matches found. This gap has been recorded — the Unfragile graph learns from every query.");
+        return lines.join("\n");
+    }
+    for (let i = 0; i < data.matches.length; i++) {
+        lines.push(formatMatch(data.matches[i], i + 1));
+        lines.push("");
+    }
+    // Include matchRecordIds for feedback
+    const ids = data.graphSignal.matchRecordIds;
+    if (ids && ids.length > 0) {
+        lines.push(`\n_Match record IDs (for feedback): ${ids.join(", ")}_`);
+    }
+    return lines.join("\n");
+}
+// ─── MCP Server ──────────────────────────────────────────────
+const server = new McpServer({
+    name: "unfragile",
+    version: "0.1.0",
+});
+// Tool 1: General search
+server.tool("search", "Search the Unfragile match graph for AI tools, frameworks, APIs, MCP servers, agents, and more. Returns ranked results with capability matches and graph signals. Every query feeds the graph.", {
+    query: z.string().min(2).max(500).describe("What you're looking for (e.g., 'best framework for building AI agents', 'MCP server for database access')"),
+    limit: z.number().min(1).max(20).default(5).describe("Max results to return"),
+    type: z.enum(["agent", "api", "app", "benchmark", "cli", "dataset", "extension", "finetune", "framework", "mcp", "model", "platform", "product", "prompt", "repo", "skill", "template", "webapp", "workflow"]).optional().describe("Filter by artifact type"),
+}, async ({ query, limit, type }) => {
+    log("search", query);
+    try {
+        const data = await searchAPI(query, { limit, type });
+        return { content: [{ type: "text", text: formatResults(data) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+});
+// Tool 2: Find MCP servers
+server.tool("find_mcps", "Find MCP servers by capability need. Use this when you need to discover MCP servers for specific integrations (e.g., databases, APIs, cloud services). Returns MCP servers ranked by capability match.", {
+    need: z.string().min(2).max(500).describe("What capability you need (e.g., 'Postgres database access', 'Slack messaging', 'GitHub repository management')"),
+    limit: z.number().min(1).max(20).default(5).describe("Max results"),
+}, async ({ need, limit }) => {
+    log("find_mcps", need);
+    try {
+        const data = await searchAPI(`MCP server for ${need}`, { limit, type: "mcp" });
+        const text = formatResults(data);
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+});
+// Tool 3: Get artifact details
+server.tool("get_artifact", "Get full details and capabilities for a specific AI artifact by name or slug. Uses search-based lookup (best-effort name matching — may return a different artifact for ambiguous names like 'express'). Use this to understand what an artifact can do before adding it to your stack.", {
+    name: z.string().min(1).max(200).describe("Artifact name or slug (e.g., 'cursor', 'langchain', 'claude-code')"),
+}, async ({ name }) => {
+    log("get_artifact", name);
+    try {
+        const data = await searchAPI(name, { limit: 3 });
+        // Find best match by name
+        const match = data.matches.find((m) => m.artifact.name.toLowerCase() === name.toLowerCase() ||
+            m.artifact.slug === name.toLowerCase().replace(/\s+/g, "-")) || data.matches[0];
+        if (!match) {
+            return { content: [{ type: "text", text: `No artifact found matching "${name}".` }] };
+        }
+        const lines = [];
+        lines.push(`# ${match.artifact.name}`);
+        lines.push(`**Type:** ${match.artifact.type} | **UnfragileRank:** ${match.artifact.unfragileRank}/100`);
+        lines.push(`**URL:** ${match.artifact.url}`);
+        lines.push(`**Verified:** ${match.artifact.verified ? "Yes ✓" : "No"}`);
+        lines.push(`**Pricing:** ${match.artifact.pricing.free ? "Free" : match.artifact.pricing.model}`);
+        lines.push(`**Categories:** ${match.artifact.categories.join(", ")}`);
+        if (match.artifact.description)
+            lines.push(`\n${match.artifact.description}`);
+        if (match.capabilities.length > 0) {
+            lines.push("\n## Capabilities");
+            for (const cap of match.capabilities) {
+                lines.push(`\n### ${cap.name}`);
+                if (cap.description)
+                    lines.push(cap.description);
+                if (cap.bestFor.length > 0)
+                    lines.push(`\n**Best for:** ${cap.bestFor.join(", ")}`);
+                if (cap.limitations.length > 0)
+                    lines.push(`**Limitations:** ${cap.limitations.join(", ")}`);
+            }
+        }
+        if (match.matchGraph.timesMatched > 0) {
+            lines.push(`\n## Graph Signal`);
+            lines.push(`Matched ${match.matchGraph.timesMatched} times | ${Math.round(match.matchGraph.successRate * 100)}% success rate`);
+            if (match.matchGraph.topIntents.length > 0) {
+                lines.push(`Top intents: ${match.matchGraph.topIntents.join(", ")}`);
+            }
+        }
+        lines.push(`\n→ Full details: ${match.artifact.pageUrl}`);
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+});
+// Tool 4: Compare artifacts
+server.tool("compare", "Compare two AI artifacts side-by-side. Shows capabilities, pricing, rank, and graph signals for each. Uses search-based lookup (best-effort name matching). Use this when deciding between alternatives.", {
+    artifact_a: z.string().min(1).max(200).describe("First artifact name (e.g., 'cursor')"),
+    artifact_b: z.string().min(1).max(200).describe("Second artifact name (e.g., 'windsurf')"),
+}, async ({ artifact_a, artifact_b }) => {
+    log("compare", `${artifact_a} vs ${artifact_b}`);
+    try {
+        const [dataA, dataB] = await Promise.all([
+            searchAPI(artifact_a, { limit: 1 }),
+            searchAPI(artifact_b, { limit: 1 }),
+        ]);
+        const matchA = dataA.matches[0];
+        const matchB = dataB.matches[0];
+        if (!matchA && !matchB) {
+            return { content: [{ type: "text", text: `Neither "${artifact_a}" nor "${artifact_b}" found.` }] };
+        }
+        const lines = [];
+        lines.push(`# Compare: ${matchA?.artifact.name || artifact_a} vs ${matchB?.artifact.name || artifact_b}\n`);
+        const row = (label, a, b) => `| ${label} | ${a} | ${b} |`;
+        lines.push(`| | ${matchA?.artifact.name || "Not found"} | ${matchB?.artifact.name || "Not found"} |`);
+        lines.push(`|---|---|---|`);
+        if (matchA && matchB) {
+            lines.push(row("Type", matchA.artifact.type, matchB.artifact.type));
+            lines.push(row("UnfragileRank", `${matchA.artifact.unfragileRank}/100`, `${matchB.artifact.unfragileRank}/100`));
+            lines.push(row("Pricing", matchA.artifact.pricing.free ? "Free" : matchA.artifact.pricing.model, matchB.artifact.pricing.free ? "Free" : matchB.artifact.pricing.model));
+            lines.push(row("Verified", matchA.artifact.verified ? "✓" : "No", matchB.artifact.verified ? "✓" : "No"));
+            lines.push(row("Times Matched", String(matchA.matchGraph.timesMatched), String(matchB.matchGraph.timesMatched)));
+            lines.push(row("Capabilities", String(matchA.capabilities.length), String(matchB.capabilities.length)));
+            lines.push(`\n## ${matchA.artifact.name} Capabilities`);
+            for (const cap of matchA.capabilities) {
+                lines.push(`- **${cap.name}**: ${cap.description.slice(0, 150)}`);
+            }
+            lines.push(`\n## ${matchB.artifact.name} Capabilities`);
+            for (const cap of matchB.capabilities) {
+                lines.push(`- **${cap.name}**: ${cap.description.slice(0, 150)}`);
+            }
+            lines.push(`\n→ Full comparison: https://unfragile.ai/compare/${matchA.artifact.slug}-vs-${matchB.artifact.slug}`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+});
+// Tool 5: Find harness stack
+server.tool("find_stack", "Assemble a complete AI harness stack for a use case. Given a description of what you're building, returns recommended tools across harness layers: orchestration, tools/MCPs, memory, guardrails, context assembly, and evaluation. This is the key differentiator — Unfragile understands that modern AI systems are composed of 5-15 tools working together.", {
+    description: z.string().min(10).max(1000).describe("What you're building (e.g., 'a customer support agent that connects to our Postgres database and Slack, with memory of past conversations')"),
+    focus: z.enum(["full", "tools-only", "infrastructure"]).default("full").describe("Stack focus: 'full' = all layers, 'tools-only' = just MCPs and integrations, 'infrastructure' = frameworks and platforms"),
+}, async ({ description, focus }) => {
+    log("find_stack", description);
+    try {
+        // Parallel queries across harness layers
+        const layers = focus === "tools-only"
+            ? [
+                { name: "MCP Servers / Tools", query: `MCP server for ${description}`, type: "mcp" },
+                { name: "APIs", query: `API for ${description}`, type: "api" },
+                { name: "Extensions", query: `extension for ${description}`, type: "extension" },
+            ]
+            : focus === "infrastructure"
+                ? [
+                    { name: "Frameworks", query: `framework for ${description}`, type: "framework" },
+                    { name: "Platforms", query: `platform for ${description}`, type: "platform" },
+                    { name: "CLI Tools", query: `CLI for ${description}`, type: "cli" },
+                ]
+                : [
+                    { name: "Orchestration / Framework", query: `agent framework for ${description}`, type: "framework" },
+                    { name: "MCP Servers / Tools", query: `MCP server for ${description}`, type: "mcp" },
+                    { name: "APIs", query: `API for ${description}`, type: "api" },
+                    { name: "Agents", query: `agent for ${description}`, type: "agent" },
+                    { name: "CLI Tools", query: `CLI tool for ${description}`, type: "cli" },
+                ];
+        const results = await Promise.all(layers.map(async (layer) => {
+            try {
+                const data = await searchAPI(layer.query, { limit: 3, type: layer.type });
+                return { layer: layer.name, matches: data.matches };
+            }
+            catch {
+                return { layer: layer.name, matches: [] };
+            }
+        }));
+        const lines = [];
+        lines.push(`# Harness Stack for: ${description}\n`);
+        lines.push(`> Every AI system is a harness — the model is just one component.`);
+        lines.push(`> Here's a recommended stack assembled from the Unfragile match graph.\n`);
+        let totalTools = 0;
+        for (const { layer, matches } of results) {
+            if (matches.length === 0)
+                continue;
+            totalTools += matches.length;
+            lines.push(`## ${layer}\n`);
+            for (const m of matches) {
+                const verified = m.artifact.verified ? " ✓" : "";
+                const pricing = m.artifact.pricing.free ? "Free" : m.artifact.pricing.model;
+                lines.push(`**${m.artifact.name}${verified}** — ${pricing} | Rank: ${m.artifact.unfragileRank}/100`);
+                if (m.artifact.description)
+                    lines.push(`${m.artifact.description.slice(0, 200)}`);
+                if (m.capabilities.length > 0) {
+                    const capNames = m.capabilities.slice(0, 3).map((c) => c.name).join(", ");
+                    lines.push(`Key capabilities: ${capNames}`);
+                }
+                lines.push(`→ ${m.artifact.url}\n`);
+            }
+        }
+        if (totalTools === 0) {
+            lines.push("No matching tools found for this use case. This gap has been recorded — the Unfragile graph learns from every query.");
+        }
+        else {
+            lines.push(`---`);
+            lines.push(`*${totalTools} tools across ${results.filter((r) => r.matches.length > 0).length} harness layers. Every query improves the graph.*`);
+            lines.push(`*Browse more: https://unfragile.ai/hub*`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+});
+// Tool 6: Feedback — close the learning loop
+server.tool("feedback", "Report whether a recommended tool worked or not. This closes the learning loop — the Unfragile graph uses this feedback to improve future recommendations. Call this after trying a tool from search results.", {
+    matchRecordId: z.string().min(1).describe("Match record ID from search results (shown at the bottom of search output)"),
+    outcome: z.enum(["success", "failure"]).describe("Did the recommended tool work for your use case?"),
+    comment: z.string().max(500).optional().describe("Optional: brief note on why it worked or didn't"),
+}, async ({ matchRecordId, outcome, comment }) => {
+    log("feedback", `${matchRecordId} → ${outcome}`);
+    try {
+        const headers = { "Content-Type": "application/json" };
+        if (API_KEY)
+            headers["X-API-Key"] = API_KEY;
+        const body = {
+            matchRecordId,
+            outcome: outcome === "success" ? "success" : "failure",
+            clickedThrough: true,
+            source: SOURCE,
+        };
+        if (comment)
+            body.comment = comment;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 10_000);
+        try {
+            const res = await fetch(`${API_BASE}/api/feedback`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`Feedback API error ${res.status}: ${text}`);
+            }
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Feedback recorded: ${outcome}. The Unfragile graph will use this to improve future recommendations. Thank you!`,
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Error sending feedback: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+});
+// ─── Start ───────────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[unfragile] MCP server started");
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@unfragile/mcp-server",
+  "version": "0.1.0",
+  "description": "Unfragile MCP Server — query the match graph for AI from any agent. Find AI tools, assemble harness stacks, compare artifacts.",
+  "keywords": [
+    "mcp",
+    "ai",
+    "tools",
+    "discovery",
+    "unfragile",
+    "harness-engineering"
+  ],
+  "license": "MIT",
+  "author": "Unfragile <hello@unfragile.ai>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Savirinc/Unfragile.ai",
+    "directory": "mcp-server"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "unfragile-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "tsx": "^4.19.4",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}