{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"npm_npm-claude-flowmcp","slug":"npm-claude-flowmcp","name":"@claude-flow/mcp","type":"mcp","url":"https://www.npmjs.com/package/@claude-flow/mcp","page_url":"https://unfragile.ai/npm-claude-flowmcp","categories":["mcp-servers"],"tags":["mcp","model-context-protocol","claude","ai-agents","json-rpc","stdio","websocket","tool-registry"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"npm_npm-claude-flowmcp__cap_0","uri":"capability://tool.use.integration.multi.transport.mcp.server.with.stdio.http.websocket.support","name":"multi-transport mcp server with stdio/http/websocket support","description":"Implements a standalone Model Context Protocol server that accepts client connections via three distinct transport mechanisms: stdio (for local process communication), HTTP (for REST-based polling or long-polling), and WebSocket (for bidirectional real-time communication). The server handles JSON-RPC 2.0 message framing and routing across all transports, allowing a single MCP server instance to serve multiple client types simultaneously without transport-specific business logic.","intents":["I need my MCP server to work with Claude Desktop (stdio), web-based clients (WebSocket), and legacy HTTP integrations simultaneously","I want to deploy a single MCP server that clients can connect to via their preferred transport without rebuilding","I need to support both synchronous HTTP clients and asynchronous WebSocket subscribers on the same server instance"],"best_for":["Teams building MCP servers that need to support multiple client ecosystems (Claude Desktop, web UIs, mobile apps)","Developers migrating existing tools to MCP who need backward-compatible HTTP access alongside native MCP clients","Infrastructure teams deploying centralized tool servers that serve heterogeneous client populations"],"limitations":["HTTP transport lacks native streaming — long-polling or chunked responses required for streaming tool outputs, adding latency","Stdio transport limited to single parent process — cannot serve multiple simultaneous clients over stdio","WebSocket connections require persistent network — not suitable for intermittent or offline-first clients","No built-in load balancing across transport types — all transports share single event loop, potential bottleneck under mixed-transport load"],"requires":["Node.js 16+ (for native WebSocket support in v18+, or polyfill for v16)","MCP protocol specification understanding (JSON-RPC 2.0 message format)","For HTTP: HTTP server library (Express, Fastify, or native Node http module)","For WebSocket: WebSocket library (ws, socket.io, or native if Node 18+)"],"input_types":["JSON-RPC 2.0 request objects","MCP protocol messages (initialize, call_tool, list_resources, etc.)","HTTP POST bodies with JSON payloads","WebSocket frames with JSON-RPC messages"],"output_types":["JSON-RPC 2.0 response objects","MCP protocol response messages","HTTP response bodies with JSON","WebSocket frames with JSON-RPC responses"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_1","uri":"capability://automation.workflow.connection.pooling.and.lifecycle.management.for.mcp.clients","name":"connection pooling and lifecycle management for mcp clients","description":"Manages a pool of active client connections with automatic lifecycle tracking, including connection establishment, heartbeat/keep-alive mechanisms, graceful disconnection, and resource cleanup. The pool maintains metadata about each connection (transport type, client capabilities, session state) and handles reconnection logic for transient failures, preventing resource leaks and zombie connections.","intents":["I need to prevent memory leaks from abandoned WebSocket or HTTP connections in my MCP server","I want to detect and automatically recover from client disconnections without manual intervention","I need to track which clients are currently connected and their capabilities for routing decisions"],"best_for":["Production MCP servers handling many concurrent clients (10+)","Long-running servers that need to survive client churn without degradation","Teams needing observability into client connection state and health"],"limitations":["Pool size must be pre-configured or dynamically sized — no automatic scaling based on load","Heartbeat intervals are global — cannot tune per-client or per-transport","Connection metadata stored in-memory — lost on server restart, no persistence layer","Reconnection backoff is linear or exponential but not adaptive — cannot learn from failure patterns"],"requires":["Node.js 16+","Event emitter pattern support (native Node.js EventEmitter or equivalent)","Timeout/interval APIs (setInterval, setTimeout)"],"input_types":["Connection events (connect, disconnect, error)","Client metadata (transport type, protocol version, capabilities)","Heartbeat/ping messages"],"output_types":["Connection state (active, idle, disconnected)","Pool statistics (total connections, active, idle)","Lifecycle events (connected, reconnecting, failed)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_10","uri":"capability://tool.use.integration.resource.discovery.and.streaming.with.list.resources.and.read.resource","name":"resource discovery and streaming with list_resources and read_resource","description":"Implements MCP resource protocol methods (list_resources, read_resource) allowing servers to expose files, documents, or data as resources that clients can discover and read. Supports resource metadata (name, description, MIME type), streaming of large resources via chunked responses, and resource filtering/search. Handles resource access control and error cases (not found, permission denied).","intents":["I want to expose files or documents from my server that clients can discover and read","I need to stream large files to clients without loading them entirely into memory","I want clients to search or filter available resources before reading them"],"best_for":["MCP servers that manage files, documents, or data repositories","Teams building knowledge bases or document management systems on top of MCP","Projects requiring clients to browse server-side resources"],"limitations":["Resource streaming is unidirectional — clients cannot write back to resources","No built-in caching — repeated reads of the same resource hit the source each time","Resource metadata is static — cannot dynamically generate descriptions based on content","No pagination for list_resources — large resource lists must be returned in full"],"requires":["Node.js 16+","Resource handlers (functions that return resource metadata or content)","File system access or data source (filesystem, database, API, etc.)"],"input_types":["Resource URI or name (string)","Resource filter/search criteria (optional)"],"output_types":["Resource metadata (name, description, MIME type, size)","Resource content (text, binary, or streamed chunks)","Error responses (not found, permission denied)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_11","uri":"capability://tool.use.integration.prompt.template.management.with.list.prompts.and.get.prompt","name":"prompt template management with list_prompts and get_prompt","description":"Implements MCP prompt protocol methods (list_prompts, get_prompt) allowing servers to expose reusable prompt templates that clients can discover and instantiate. Supports prompt metadata (name, description, arguments), argument substitution, and prompt versioning. Enables clients to use server-provided prompts without hardcoding them, facilitating prompt reuse and management.","intents":["I want to provide reusable prompt templates that clients can discover and use","I need to manage prompts on the server side so clients always get the latest version","I want to expose prompts with parameters that clients can customize"],"best_for":["MCP servers that manage prompt libraries or templates","Teams building prompt management systems on top of MCP","Projects where prompts need to be versioned and updated centrally"],"limitations":["Prompt arguments are simple key-value substitutions — no complex templating logic","No built-in prompt versioning — teams must implement their own version management","Prompts are text-only — cannot include images or structured data","No validation of prompt arguments — clients can pass invalid values"],"requires":["Node.js 16+","Prompt template storage (files, database, etc.)","String templating or substitution logic"],"input_types":["Prompt name (string)","Prompt arguments (object with key-value pairs)"],"output_types":["Prompt metadata (name, description, arguments)","Instantiated prompt text with arguments substituted"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_12","uri":"capability://tool.use.integration.sampling.llm.inference.with.model.selection.and.parameter.control","name":"sampling (llm inference) with model selection and parameter control","description":"Implements MCP sampling protocol allowing servers to request LLM inference from clients, with model selection, temperature/top-p control, and streaming responses. Servers can ask clients to run inference using their configured LLM (e.g., Claude), enabling tool servers to leverage LLM capabilities without managing their own model. Supports both synchronous and streaming sampling.","intents":["I want my tool server to use the client's LLM to generate text without managing my own model","I need to control LLM parameters (temperature, top-p) when requesting inference","I want to stream LLM responses back to the client in real-time"],"best_for":["Tool servers that need LLM capabilities but don't want to manage models","Teams building agentic systems where tools can request LLM inference","Projects requiring tight integration between tools and language models"],"limitations":["Sampling only works if the client supports it — not all MCP clients implement sampling","Model selection is client-dependent — server cannot guarantee which model will be used","No built-in cost tracking — servers cannot monitor or limit inference costs","Streaming adds complexity — clients must handle partial responses and concatenation"],"requires":["Node.js 16+","MCP client that supports sampling (e.g., Claude Desktop with sampling support)","LLM API access on the client side"],"input_types":["Prompt text (string)","Model name (string, e.g., 'claude-3-sonnet')","Sampling parameters (temperature, top-p, max_tokens, etc.)"],"output_types":["LLM response text","Streaming chunks (if streaming enabled)","Stop reason (end_turn, max_tokens, etc.)"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_2","uri":"capability://tool.use.integration.tool.registry.with.schema.validation.and.multi.provider.support","name":"tool registry with schema validation and multi-provider support","description":"Provides a centralized registry for MCP tools with JSON Schema validation, allowing developers to define tools once with input/output schemas and expose them to multiple client types. The registry validates incoming tool calls against declared schemas, enforces type safety, and supports tool discovery via the MCP list_tools protocol, enabling clients to introspect available capabilities before calling them.","intents":["I want to define my tools with strict input validation so clients can't call them with malformed arguments","I need clients to discover what tools are available and their parameters before making calls","I want to reuse the same tool definitions across multiple MCP clients without duplicating schemas"],"best_for":["Developers building MCP servers with many tools (5+) that need consistent validation","Teams where clients and servers are developed separately and need a contract (schema) to agree on","Projects requiring audit trails or compliance — schema validation provides a clear record of what was called with what arguments"],"limitations":["Schema validation is synchronous — complex schemas with custom validators may block the event loop","No built-in versioning — schema changes require coordination between server and clients","Schemas are static at registration time — cannot dynamically generate schemas based on runtime state","No support for conditional schemas — cannot express 'if parameter A is X, then parameter B is required'"],"requires":["Node.js 16+","JSON Schema validator library (ajv, joi, or equivalent)","Tool handler functions (async or sync)"],"input_types":["JSON Schema objects (for tool input/output definitions)","Tool handler functions (JavaScript/TypeScript callables)","Tool call requests with arguments"],"output_types":["Tool metadata (name, description, schema)","Validation results (pass/fail with error details)","Tool execution results"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_3","uri":"capability://tool.use.integration.json.rpc.2.0.message.framing.and.error.handling","name":"json-rpc 2.0 message framing and error handling","description":"Implements complete JSON-RPC 2.0 protocol compliance with automatic message framing, ID tracking, error code mapping, and response correlation. Handles malformed requests, missing required fields, invalid method names, and server errors with proper JSON-RPC error responses (including error codes like -32600 for invalid request, -32601 for method not found). Supports both request-response and notification patterns (requests without IDs that expect no response).","intents":["I need my MCP server to properly reject invalid requests and return standard JSON-RPC error codes","I want to correlate responses with requests even when they arrive out of order","I need to support both request-response and fire-and-forget notification patterns"],"best_for":["Any MCP server implementation — this is a protocol requirement","Teams integrating with multiple MCP clients that expect strict JSON-RPC compliance","Developers debugging client-server communication issues who need clear error messages"],"limitations":["Strict JSON-RPC compliance means non-compliant clients will receive error responses — no graceful degradation","Error codes are fixed by JSON-RPC spec — cannot add custom error codes without violating spec","No support for batch requests (JSON-RPC 2.0 extension) — each request must be handled individually","Message framing overhead adds ~50-100 bytes per request for ID and jsonrpc version fields"],"requires":["Node.js 16+","JSON parsing/serialization (native JSON object)","Understanding of JSON-RPC 2.0 specification"],"input_types":["Raw JSON-RPC 2.0 request strings or objects","Requests with or without ID field (notifications)"],"output_types":["JSON-RPC 2.0 response objects with matching ID","JSON-RPC 2.0 error objects with standard error codes","No response for notifications (by spec)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_4","uri":"capability://tool.use.integration.mcp.protocol.method.routing.and.dispatch","name":"mcp protocol method routing and dispatch","description":"Routes incoming MCP protocol methods (initialize, list_tools, call_tool, list_resources, read_resource, etc.) to appropriate handlers based on method name and request type. Maintains a method registry where developers can register custom handlers for standard MCP methods, with automatic parameter extraction and response formatting. Supports both built-in MCP methods and custom extensions, with fallback to 'method not found' errors for unregistered methods.","intents":["I want to handle MCP protocol methods (like call_tool) without manually parsing the request structure","I need to register custom handlers for MCP methods and have them automatically invoked with the right parameters","I want to extend MCP with custom methods beyond the standard protocol"],"best_for":["MCP server developers who want to focus on tool/resource logic rather than protocol routing","Teams building MCP servers with custom extensions or non-standard methods","Projects requiring middleware or interceptors for method calls (logging, auth, rate limiting)"],"limitations":["Method routing is synchronous — cannot dynamically route based on async state (e.g., checking a database)","No built-in middleware chain — custom interceptors require manual wrapping of handlers","Parameter extraction assumes fixed structure — cannot handle polymorphic requests with different parameter sets","No automatic documentation generation from registered methods — clients must know method signatures out-of-band"],"requires":["Node.js 16+","Handler functions (async or sync)","Understanding of MCP protocol method signatures"],"input_types":["MCP method names (string)","Request parameters (object)","Handler functions"],"output_types":["Handler invocation with extracted parameters","Response objects matching MCP protocol","Error responses for unregistered methods"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_5","uri":"capability://tool.use.integration.stdio.transport.with.process.level.communication","name":"stdio transport with process-level communication","description":"Implements MCP stdio transport for local inter-process communication, where the MCP server reads JSON-RPC messages from stdin and writes responses to stdout. Handles process lifecycle (parent process exit detection), signal handling (SIGTERM, SIGINT), and proper cleanup of file descriptors. Supports the stdio transport used by Claude Desktop and other local MCP clients, enabling seamless integration with local development environments.","intents":["I want my MCP server to work with Claude Desktop without needing a network server","I need my tool server to run as a subprocess and communicate via stdin/stdout","I want to integrate with local development tools that spawn MCP servers as child processes"],"best_for":["Claude Desktop users building local tool servers","Developers integrating MCP into local development workflows (IDEs, CLIs)","Teams with existing subprocess-based tool architectures"],"limitations":["Stdio transport is single-client only — cannot serve multiple simultaneous clients","Binary data must be base64-encoded — not suitable for large file transfers","No built-in multiplexing — all communication is sequential over single stdin/stdout pair","Process exit is abrupt — graceful shutdown requires explicit signal handling code"],"requires":["Node.js 16+","Parent process that spawns the server (e.g., Claude Desktop, custom launcher)","Signal handler support (process.on('SIGTERM'))"],"input_types":["JSON-RPC messages on stdin (newline-delimited)","Process signals (SIGTERM, SIGINT)"],"output_types":["JSON-RPC responses on stdout (newline-delimited)","Error messages on stderr"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_6","uri":"capability://tool.use.integration.http.transport.with.request.response.polling","name":"http transport with request-response polling","description":"Implements MCP HTTP transport where clients send JSON-RPC requests via HTTP POST and receive responses via HTTP responses. Supports both synchronous request-response (client waits for response) and long-polling patterns (client polls for responses). Handles HTTP status codes, CORS headers, and content negotiation. Integrates with standard Node.js HTTP servers or frameworks like Express, allowing MCP servers to be exposed as HTTP APIs.","intents":["I want to expose my MCP server as an HTTP API for web clients or REST integrations","I need to support clients that can only make HTTP requests (browsers, legacy systems)","I want to add MCP capabilities to an existing HTTP server without running a separate process"],"best_for":["Web-based MCP clients (React, Vue, etc.)","Teams integrating MCP into existing HTTP/REST architectures","Developers building MCP gateways or proxies"],"limitations":["HTTP is request-response only — no server-initiated messages or streaming without long-polling","Long-polling adds latency and overhead compared to WebSocket — not suitable for real-time interactions","CORS requirements may complicate browser-based clients — requires careful header configuration","HTTP overhead (headers, connection setup) makes it less efficient than WebSocket for high-frequency calls"],"requires":["Node.js 16+","HTTP server (native http module, Express, Fastify, etc.)","HTTP client library (fetch, axios, etc.)"],"input_types":["HTTP POST requests with JSON-RPC body","HTTP headers (Content-Type, Authorization, etc.)"],"output_types":["HTTP 200 responses with JSON-RPC response body","HTTP error responses (400, 500, etc.) with error details"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_7","uri":"capability://tool.use.integration.websocket.transport.with.bidirectional.streaming","name":"websocket transport with bidirectional streaming","description":"Implements MCP WebSocket transport for bidirectional, full-duplex communication where both client and server can send messages independently. Handles WebSocket connection lifecycle (upgrade, ping/pong, close), automatic reconnection on client side, and streaming of large responses. Supports both text frames (JSON) and binary frames, with automatic serialization/deserialization. Enables real-time tool interactions and server-initiated notifications.","intents":["I want real-time, bidirectional communication between my MCP client and server","I need to stream large tool responses without waiting for the entire response to be ready","I want the server to push notifications or updates to clients without polling"],"best_for":["Web-based MCP clients requiring real-time interactions","Teams building collaborative tools where multiple clients need server-pushed updates","High-frequency tool calling scenarios where latency matters"],"limitations":["WebSocket requires persistent connection — not suitable for intermittent or mobile clients with poor connectivity","Requires WebSocket support in both client and server — cannot use with legacy HTTP-only clients","Connection state must be managed — reconnection logic adds complexity","No built-in message ordering guarantees — out-of-order delivery possible with concurrent messages"],"requires":["Node.js 16+ (native WebSocket in 18+, or ws library for 16)","WebSocket client library (ws, socket.io, native WebSocket API in browsers)","HTTP server that supports WebSocket upgrade (Express with ws, Fastify, etc.)"],"input_types":["WebSocket frames with JSON-RPC messages","Binary frames with serialized data","Ping/pong frames for keep-alive"],"output_types":["WebSocket frames with JSON-RPC responses","Server-initiated messages (notifications)","Streaming responses (chunked across multiple frames)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_8","uri":"capability://tool.use.integration.server.initialization.and.capability.negotiation","name":"server initialization and capability negotiation","description":"Handles the MCP server initialization handshake where the server declares its capabilities (supported tools, resources, prompts, etc.) and the client declares its capabilities. Implements the initialize method that exchanges protocol version, server name/version, and feature flags. Stores negotiated capabilities for use in subsequent method calls, enabling clients to understand what the server can do before making requests.","intents":["I want clients to know what version of MCP my server supports and what features are available","I need to negotiate capabilities with clients so I can adapt my behavior based on what they support","I want to declare my server's identity and version for logging and debugging"],"best_for":["Any MCP server — initialization is a protocol requirement","Teams with multiple MCP server versions that need backward compatibility","Developers building MCP clients that need to adapt to different server capabilities"],"limitations":["Initialization is one-time only — cannot renegotiate capabilities after connection is established","Capabilities are static — cannot dynamically enable/disable features based on runtime state","No versioning strategy built-in — teams must define their own compatibility rules","Client capabilities are informational only — server cannot enforce client requirements"],"requires":["Node.js 16+","Server metadata (name, version)","MCP protocol version specification"],"input_types":["Client initialize request with client info and capabilities","Protocol version from client"],"output_types":["Server initialize response with server info and capabilities","Protocol version confirmation","Capability flags (tools, resources, prompts, etc.)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm_npm-claude-flowmcp__cap_9","uri":"capability://tool.use.integration.tool.execution.with.input.validation.and.error.handling","name":"tool execution with input validation and error handling","description":"Executes registered tools in response to call_tool requests, with automatic input validation against declared schemas, timeout enforcement, and error handling. Captures tool output (success or error), formats responses according to MCP protocol, and handles exceptions gracefully. Supports both synchronous and asynchronous tool handlers, with automatic promise resolution and error propagation.","intents":["I want to call tools with automatic validation of input arguments","I need to enforce timeouts on tool execution to prevent hanging","I want consistent error handling and response formatting across all tools"],"best_for":["MCP servers with multiple tools that need consistent execution semantics","Teams requiring strict input validation and error handling","Projects with long-running tools that need timeout protection"],"limitations":["Timeouts are process-level — cannot interrupt long-running synchronous code, only async operations","Error handling is synchronous — cannot catch errors from tools that spawn external processes","No built-in retry logic — failed tools must be retried by the client","Tool output is captured in memory — not suitable for tools producing very large outputs (>100MB)"],"requires":["Node.js 16+","Tool handler functions (async or sync)","JSON Schema validator for input validation"],"input_types":["Tool name (string)","Tool arguments (object)","Timeout duration (milliseconds)"],"output_types":["Tool result (success with output or error with message)","Execution time metadata","Error details (code, message, stack trace)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":34,"verified":false,"data_access_risk":"high","permissions":["Node.js 16+ (for native WebSocket support in v18+, or polyfill for v16)","MCP protocol specification understanding (JSON-RPC 2.0 message format)","For HTTP: HTTP server library (Express, Fastify, or native Node http module)","For WebSocket: WebSocket library (ws, socket.io, or native if Node 18+)","Node.js 16+","Event emitter pattern support (native Node.js EventEmitter or equivalent)","Timeout/interval APIs (setInterval, setTimeout)","Resource handlers (functions that return resource metadata or content)","File system access or data source (filesystem, database, API, etc.)","Prompt template storage (files, database, etc.)"],"failure_modes":["HTTP transport lacks native streaming — long-polling or chunked responses required for streaming tool outputs, adding latency","Stdio transport limited to single parent process — cannot serve multiple simultaneous clients over stdio","WebSocket connections require persistent network — not suitable for intermittent or offline-first clients","No built-in load balancing across transport types — all transports share single event loop, potential bottleneck under mixed-transport load","Pool size must be pre-configured or dynamically sized — no automatic scaling based on load","Heartbeat intervals are global — cannot tune per-client or per-transport","Connection metadata stored in-memory — lost on server restart, no persistence layer","Reconnection backoff is linear or exponential but not adaptive — cannot learn from failure patterns","Resource streaming is unidirectional — clients cannot write back to resources","No built-in caching — repeated reads of the same resource hit the source each time","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.5,"ecosystem":0.5000000000000001,"match_graph":0.25,"freshness":0.6,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:23.903Z","last_scraped_at":"2026-05-03T14:23:53.466Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=npm-claude-flowmcp","compare_url":"https://unfragile.ai/compare?artifact=npm-claude-flowmcp"}},"signature":"K11jlXPzduZFRgqhMnVMHUI13rwC4XkpEW6MMc0f0kfN95Lev3pMX59x0BVNUkVyKhiDdD5LRagJmNI+xILvBw==","signedAt":"2026-06-20T22:44:38.636Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/npm-claude-flowmcp","artifact":"https://unfragile.ai/npm-claude-flowmcp","verify":"https://unfragile.ai/api/v1/verify?slug=npm-claude-flowmcp","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}