{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-mastra-mcp","slug":"mastra-mcp","name":"Mastra/mcp","type":"mcp","url":"https://github.com/mastra-ai/mastra/tree/main/packages/mcp","page_url":"https://unfragile.ai/mastra-mcp","categories":["mcp-servers"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-mastra-mcp__cap_0","uri":"capability://tool.use.integration.mcp.server.protocol.client.implementation.with.multi.provider.transport","name":"mcp server protocol client implementation with multi-provider transport","description":"Implements the Model Context Protocol (MCP) client specification with support for stdio, SSE, and WebSocket transports. The client handles bidirectional JSON-RPC 2.0 message framing, automatic reconnection with exponential backoff, and capability negotiation during the initialization handshake. Built on top of Mastra's core message routing system, it abstracts transport layer complexity while maintaining full protocol compliance for tool discovery, resource access, and prompt management.","intents":["Connect to MCP-compatible servers without managing transport protocol details","Discover available tools and resources from remote MCP servers dynamically","Execute remote tools through a unified interface regardless of server transport","Handle connection failures and reconnection transparently in production environments"],"best_for":["Teams building AI agents that need to integrate with Claude Desktop or other MCP-compatible tools","Developers migrating from REST-based tool integrations to the standardized MCP protocol","Applications requiring dynamic tool discovery from multiple MCP servers"],"limitations":["No built-in request batching — each tool call is a separate JSON-RPC message, adding latency for high-frequency operations","Transport-specific limitations: stdio transport limited to local processes, SSE requires HTTP/1.1 compatibility, WebSocket requires persistent connection support","Capability negotiation happens once at initialization — dynamic capability changes require reconnection","No built-in caching of tool schemas — repeated tool discovery queries hit the server each time"],"requires":["Node.js 18+ for native WebSocket and stream handling","MCP server compatible with protocol version 2024-11-05 or later","For stdio transport: direct process spawning capability","For SSE/WebSocket: network connectivity to MCP server endpoint"],"input_types":["MCP server configuration (host, port, transport type, authentication)","Tool invocation requests with typed parameters matching server schema","Resource URIs for accessing server-provided resources"],"output_types":["Tool execution results (JSON-structured or text)","Resource content (text, binary, or structured data)","Server capability metadata (available tools, resources, prompts)"],"categories":["tool-use-integration","protocol-implementation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-mastra-mcp__cap_1","uri":"capability://tool.use.integration.dynamic.tool.schema.translation.and.validation.with.provider.agnostic.execution","name":"dynamic tool schema translation and validation with provider-agnostic execution","description":"Translates MCP tool schemas (JSON Schema format) into Mastra's internal tool representation, enabling unified execution regardless of whether tools come from MCP servers, native Mastra tools, or external APIs. The system performs runtime schema validation using Zod, converts parameter types between protocol representations, and maps execution results back to the agent's expected output format. This abstraction layer allows agents to treat all tool sources identically while maintaining type safety and error handling consistency.","intents":["Use tools from MCP servers in agents without rewriting tool definitions","Mix MCP-sourced tools with native Mastra tools in the same agent workflow","Validate tool parameters at runtime before execution to catch schema mismatches early","Handle tool execution errors uniformly across different tool sources"],"best_for":["Agents that need to compose tools from multiple sources (MCP, native, REST APIs)","Teams building tool ecosystems where schema consistency is critical","Applications requiring strict type validation before tool execution"],"limitations":["Schema translation is one-directional (MCP → Mastra) — cannot export Mastra tools as MCP servers without additional wrapper code","Complex nested schemas with conditional properties may lose semantic information during translation","Runtime validation adds ~5-15ms per tool invocation for complex schemas","No automatic schema versioning — breaking changes in MCP server schemas require manual migration"],"requires":["Zod 3.22+ for schema validation","JSON Schema-compliant tool definitions from MCP servers","TypeScript 4.9+ for type inference from translated schemas"],"input_types":["MCP tool schema (JSON Schema format with title, description, inputSchema)","Tool invocation parameters (JSON object matching schema)","Execution context (user, workspace, request metadata)"],"output_types":["Validated parameter object (typed according to schema)","Tool execution result (success or error with structured error details)","Execution metadata (duration, token usage, tool version)"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-mastra-mcp__cap_10","uri":"capability://tool.use.integration.batch.mcp.tool.invocation.with.result.aggregation","name":"batch mcp tool invocation with result aggregation","description":"Enables agents to invoke multiple MCP tools in parallel or sequence, with automatic result aggregation and error handling. The system batches tool calls to the same MCP server to reduce round-trips, implements parallel execution for tools on different servers, and provides result aggregation strategies (collect all, fail-fast, partial success). Batch execution is transparent to agents — they specify tool calls and the system optimizes execution automatically.","intents":["Invoke multiple tools in parallel to reduce total execution time","Batch tool calls to the same server to reduce network overhead","Aggregate results from multiple tools for complex reasoning tasks","Handle partial failures where some tools succeed and others fail"],"best_for":["Agents that need to gather information from multiple tools before reasoning","Applications where execution latency is critical and parallelization helps","Complex workflows that require results from multiple sources"],"limitations":["Parallel execution adds complexity to error handling — partial failures must be handled explicitly","Batching is limited by MCP server support — not all servers support batch operations","Result aggregation may be slow if one tool is significantly slower than others (stragglers)","No automatic retry of individual failed tools in a batch — entire batch may need to be retried"],"requires":["Multiple MCP tools or servers to benefit from batching/parallelization","Batch execution configuration (parallel vs. sequential, aggregation strategy)"],"input_types":["List of tool invocation requests","Execution strategy (parallel, sequential, or hybrid)","Aggregation strategy (collect all, fail-fast, partial success)"],"output_types":["Aggregated results from all tools","Error details for failed tools (if using partial success strategy)","Execution metrics (total latency, parallelization efficiency)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-mastra-mcp__cap_11","uri":"capability://tool.use.integration.mcp.tool.result.caching.with.invalidation.strategies","name":"mcp tool result caching with invalidation strategies","description":"Caches results from MCP tool invocations to avoid repeated execution of expensive or deterministic operations. The system implements multiple cache invalidation strategies (TTL-based, event-based, manual), allows tools to specify cache behavior (cacheable, non-cacheable, cache-with-validation), and integrates with Mastra's memory system for cross-agent cache sharing. Cache hits are tracked in observability for performance analysis.","intents":["Avoid repeated execution of expensive MCP tools within the same agent run","Share tool results across multiple agents in the same workspace","Reduce latency for deterministic tools by caching results","Control cache behavior per-tool to balance freshness and performance"],"best_for":["Agents that invoke the same tools multiple times with identical parameters","Applications where tool execution is expensive (API calls, database queries)","Multi-agent systems where tool results can be safely shared"],"limitations":["Cache invalidation is complex for tools with side effects — caching may hide state changes","TTL-based invalidation may serve stale data if tool results change frequently","Cache memory usage grows unbounded without size limits — requires explicit cache eviction","Cache hits are only possible for identical parameters — similar but different parameters miss the cache"],"requires":["Cache storage backend (in-memory, Redis, or Mastra's memory system)","Cache configuration per tool (TTL, invalidation strategy, size limits)","Tool metadata indicating whether results are cacheable"],"input_types":["Tool invocation request (name, parameters)","Cache configuration (TTL, invalidation strategy, cache key generation)"],"output_types":["Tool result (from cache or fresh execution)","Cache status (hit, miss, expired, invalidated)","Cache metadata (age, invalidation time, hit count)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-mastra-mcp__cap_2","uri":"capability://tool.use.integration.persistent.mcp.server.connection.pooling.with.automatic.lifecycle.management","name":"persistent mcp server connection pooling with automatic lifecycle management","description":"Manages a pool of MCP server connections with automatic initialization, health checking, and graceful shutdown. Each connection maintains state including negotiated capabilities, available tools, and resource metadata. The system implements connection reuse to avoid repeated initialization handshakes, automatic reconnection on failure with exponential backoff, and cleanup of stale connections. Built on Node.js EventEmitter for lifecycle events, it integrates with Mastra's observability system to track connection health and tool availability.","intents":["Maintain long-lived connections to MCP servers without repeated initialization overhead","Automatically recover from temporary network failures or server restarts","Monitor MCP server health and tool availability in production","Cleanly shutdown all MCP connections when the agent or application terminates"],"best_for":["Production agents that invoke MCP tools frequently and need low-latency execution","Multi-tenant applications where connection pooling reduces per-user overhead","Teams running MCP servers on unreliable networks or with periodic maintenance windows"],"limitations":["Connection pool size is fixed at initialization — cannot dynamically add/remove MCP servers without restart","No connection affinity — tool calls may be routed to different server instances if multiple servers expose the same tool","Health checks add periodic network overhead (~1 check per 30 seconds per connection by default)","Stale tool schema caches may cause tool calls to fail if server tools change without reconnection"],"requires":["Node.js 18+ with EventEmitter support","MCP servers must support the initialization handshake within 5 seconds (configurable)","Network connectivity to all configured MCP server endpoints"],"input_types":["MCP server configuration array (host, port, transport, auth credentials)","Connection pool options (max connections, health check interval, reconnection strategy)","Tool invocation requests routed through the pool"],"output_types":["Connection status events (connected, disconnected, error)","Tool execution results from pooled connections","Health check metrics (latency, success rate, tool availability)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-mastra-mcp__cap_3","uri":"capability://memory.knowledge.tool.discovery.and.schema.caching.with.lazy.loading","name":"tool discovery and schema caching with lazy loading","description":"Discovers available tools from MCP servers during initialization and caches tool schemas locally to avoid repeated server queries. Uses lazy loading to defer schema fetching for tools that may never be invoked, reducing startup time and memory overhead. The cache is invalidated on reconnection or when explicitly refreshed, and supports TTL-based expiration for long-running agents. Tool discovery integrates with Mastra's agent planning system to inform which tools are available for a given task.","intents":["Quickly discover what tools an MCP server provides without blocking agent initialization","Avoid repeated tool schema queries during agent execution","Understand tool capabilities (parameters, return types) before invoking them","Refresh tool availability when MCP servers are updated or restarted"],"best_for":["Agents that work with many MCP servers and need fast startup times","Applications where tool availability changes infrequently and caching is safe","Teams building tool marketplaces or discovery UIs that need to list available tools"],"limitations":["Lazy loading means first invocation of a tool has additional latency for schema fetching (~50-200ms depending on network)","Cache invalidation is manual or TTL-based — no automatic detection of tool schema changes on the server","No cache persistence across application restarts — cache is rebuilt on startup","Large tool catalogs (100+ tools) may consume significant memory even with lazy loading"],"requires":["MCP server must implement the tools/list and tools/read capabilities","In-memory cache storage (no external cache backend required)","TTL configuration if using expiration-based invalidation"],"input_types":["MCP server connection","Tool discovery request (list all tools or get specific tool schema)","Cache configuration (TTL, lazy loading enabled/disabled)"],"output_types":["Tool list with metadata (name, description, input/output schema)","Individual tool schema (parameters, return type, examples)","Cache status (hit/miss, age, invalidation time)"],"categories":["memory-knowledge","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-mastra-mcp__cap_4","uri":"capability://tool.use.integration.mcp.resource.access.and.streaming.with.content.type.negotiation","name":"mcp resource access and streaming with content type negotiation","description":"Provides access to resources exposed by MCP servers (files, documents, API responses) through a unified interface with automatic content type detection and streaming support. The system handles resource URI resolution, implements range requests for large files, and supports both text and binary content. Streaming is implemented using Node.js readable streams, enabling agents to process large resources without loading them entirely into memory. Content type negotiation allows clients to request specific formats (e.g., markdown vs. HTML for web pages).","intents":["Access files and documents from MCP servers as if they were local resources","Stream large files to agents without memory overhead","Retrieve web content or API responses through MCP resource endpoints","Handle different content types (text, binary, structured data) uniformly"],"best_for":["Agents that need to read files from remote systems (code repositories, document stores)","Applications processing large files (logs, datasets) that cannot fit in memory","Multi-source document retrieval where some sources are MCP servers"],"limitations":["Resource access is read-only — MCP does not support resource creation or modification","No built-in caching of resource content — repeated reads hit the server each time","Streaming requires keeping connections open — may timeout on slow networks or large files","Binary content handling is limited to pass-through — no automatic format conversion"],"requires":["MCP server must implement the resources/list and resources/read capabilities","Node.js 18+ for stream handling","Network connectivity to MCP server with sufficient bandwidth for resource transfer"],"input_types":["Resource URI (string identifying the resource on the MCP server)","Content type preference (optional, for content negotiation)","Range specification (optional, for partial content retrieval)"],"output_types":["Resource content (text or binary)","Readable stream for large resources","Content metadata (type, size, last modified, encoding)"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-mastra-mcp__cap_5","uri":"capability://planning.reasoning.prompt.template.management.and.execution.through.mcp","name":"prompt template management and execution through mcp","description":"Discovers and executes prompt templates exposed by MCP servers, enabling agents to use server-provided prompts for specialized tasks. The system handles prompt parameter substitution, integrates with Mastra's prompt engineering tools, and caches prompt definitions. Prompts can be composed with agent system prompts or used as standalone instructions, and execution results are tracked in the observability system for prompt performance analysis.","intents":["Use specialized prompts from MCP servers without hardcoding them in agent code","Compose multiple prompts from different sources for complex reasoning tasks","Track which prompts are most effective for different task types","Update prompts on the server without redeploying agents"],"best_for":["Teams managing prompt libraries across multiple agents and applications","Applications where prompt optimization is critical and requires A/B testing","Multi-tenant systems where different tenants need different prompts"],"limitations":["Prompt execution is synchronous — no streaming of prompt results","No built-in prompt versioning — server-side prompt changes immediately affect all agents","Limited prompt composition — cannot easily combine multiple server prompts with conditional logic","No automatic prompt validation — agents may fail if server prompts have syntax errors"],"requires":["MCP server must implement the prompts/list and prompts/get capabilities","Prompt templates must be compatible with Mastra's prompt formatting (Handlebars or similar)"],"input_types":["Prompt name or URI","Prompt parameters (key-value pairs for template substitution)","Execution context (agent state, user input, task metadata)"],"output_types":["Rendered prompt text","Prompt metadata (version, author, last updated)","Execution metrics (latency, token count, effectiveness score)"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-mastra-mcp__cap_6","uri":"capability://tool.use.integration.error.handling.and.fallback.routing.for.mcp.tool.failures","name":"error handling and fallback routing for mcp tool failures","description":"Implements comprehensive error handling for MCP tool invocations with automatic fallback to alternative tools or execution strategies. When an MCP tool fails, the system categorizes the error (network, schema mismatch, server error, timeout) and attempts recovery based on the error type. Fallback strategies include retrying with exponential backoff, routing to alternative MCP servers that expose the same tool, or falling back to native Mastra tools. Error details are logged with full context for debugging and observability.","intents":["Gracefully handle MCP server failures without breaking agent execution","Automatically retry failed tool calls with appropriate backoff strategies","Route tool calls to alternative servers when the primary server is unavailable","Provide detailed error information for debugging MCP integration issues"],"best_for":["Production agents that depend on MCP tools and need high availability","Applications with multiple MCP servers providing redundant tool capabilities","Teams building resilient multi-agent systems where tool failures should not cascade"],"limitations":["Fallback routing requires multiple MCP servers exposing the same tool — not available for unique tools","Retry logic adds latency (exponential backoff can delay execution by 10+ seconds for persistent failures)","Error categorization is heuristic-based — some errors may be misclassified and trigger wrong recovery strategy","No automatic rollback — if a tool call partially succeeds before failing, fallback execution may create duplicate side effects"],"requires":["Multiple MCP servers for fallback routing (optional but recommended)","Retry configuration (max attempts, backoff strategy, timeout thresholds)","Error classification rules (optional, uses sensible defaults)"],"input_types":["Tool invocation request","Fallback configuration (alternative tools, retry strategy, timeout)","Error context (error type, message, stack trace)"],"output_types":["Tool execution result (success or final error after all retries/fallbacks exhausted)","Error details with categorization and recovery attempt history","Metrics (retry count, fallback used, total latency)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-mastra-mcp__cap_7","uri":"capability://tool.use.integration.mcp.server.authentication.and.credential.management","name":"mcp server authentication and credential management","description":"Manages authentication credentials for MCP servers (API keys, OAuth tokens, mTLS certificates) with secure storage and automatic refresh. The system integrates with Mastra's credential management system to store secrets in encrypted vaults, supports multiple authentication schemes (bearer tokens, basic auth, custom headers), and handles token expiration with automatic refresh. Credentials are passed to MCP servers during initialization and can be rotated without restarting connections.","intents":["Securely store and manage API keys for MCP servers","Automatically refresh OAuth tokens before they expire","Use different credentials for different MCP servers in multi-tenant environments","Rotate credentials without disrupting agent execution"],"best_for":["Production systems where MCP servers require authentication","Multi-tenant applications where each tenant has different MCP server credentials","Teams with strict security requirements for credential management"],"limitations":["Credential refresh is synchronous — token refresh may block tool execution if timing is tight","No built-in credential rotation scheduling — rotation must be triggered manually or through external systems","Limited to authentication schemes supported by MCP protocol — custom authentication requires server-side support","Credentials are stored in memory during execution — no protection against memory dumps or process inspection"],"requires":["Secure credential storage backend (environment variables, vault service, or Mastra's built-in credential manager)","MCP server must support the authentication scheme being used","For OAuth: token endpoint and refresh token if using token refresh"],"input_types":["Credential type (API key, bearer token, basic auth, mTLS)","Credential value (secret, token, certificate)","Credential metadata (expiration, refresh endpoint, scope)"],"output_types":["Authentication headers for MCP server requests","Credential status (valid, expired, refresh in progress)","Audit log of credential access and rotation"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-mastra-mcp__cap_8","uri":"capability://tool.use.integration.mcp.capability.negotiation.and.version.compatibility","name":"mcp capability negotiation and version compatibility","description":"Handles MCP protocol version negotiation during server initialization, ensuring client and server are compatible before attempting tool execution. The system detects which capabilities each server supports (tools, resources, prompts, sampling) and adapts agent behavior accordingly. Version compatibility is checked at initialization and periodically during execution, with graceful degradation if servers downgrade capabilities. Incompatible servers are marked as unavailable and excluded from tool routing.","intents":["Ensure MCP client and server versions are compatible before using tools","Detect which capabilities a server supports and adapt agent behavior","Handle servers that support only a subset of MCP features","Gracefully degrade when servers lose capabilities (e.g., due to updates)"],"best_for":["Heterogeneous environments with MCP servers of different versions","Applications that need to support both old and new MCP protocol versions","Teams rolling out MCP server updates gradually without downtime"],"limitations":["Capability negotiation happens once at initialization — dynamic capability changes require reconnection","No automatic version upgrade — agents must be redeployed to use new MCP features","Graceful degradation may silently disable features without alerting operators","Version compatibility matrix must be maintained manually for complex deployments"],"requires":["MCP server must implement the initialize handshake","Client must support the MCP protocol version used by servers"],"input_types":["MCP server connection","Supported protocol versions (client-side list)","Required capabilities (list of features agent needs)"],"output_types":["Negotiated protocol version","Supported capabilities (tools, resources, prompts, sampling)","Compatibility status (compatible, degraded, incompatible)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-mastra-mcp__cap_9","uri":"capability://tool.use.integration.mcp.tool.execution.tracing.and.observability.integration","name":"mcp tool execution tracing and observability integration","description":"Integrates MCP tool execution with Mastra's observability system, emitting structured logs, traces, and metrics for all tool invocations. Each tool call is traced with full context (tool name, parameters, result, latency, error details), and traces are correlated with agent execution traces for end-to-end visibility. Metrics include tool success rate, latency percentiles, and error distribution, enabling teams to monitor MCP tool health and performance. Integration with OpenTelemetry allows exporting traces to external observability platforms.","intents":["Track which MCP tools are being used and how frequently","Measure tool execution latency and identify performance bottlenecks","Debug tool failures by examining full execution context and error details","Monitor MCP tool health and availability in production"],"best_for":["Production agents where observability is critical for debugging and monitoring","Teams using external observability platforms (Datadog, New Relic, Honeycomb)","Applications where tool performance directly impacts user experience"],"limitations":["Tracing adds overhead (~5-10ms per tool call) due to serialization and export","Trace export may fail silently if observability backend is unavailable, potentially losing data","Large tool parameters may be truncated in logs for readability, losing debugging information","Sensitive data in tool parameters must be manually redacted to avoid logging secrets"],"requires":["Observability backend (optional, but recommended for production)","OpenTelemetry SDK integration (included in Mastra)","Trace exporter configuration (OTLP, Jaeger, Datadog, etc.)"],"input_types":["Tool invocation request","Execution context (agent, user, request ID)","Observability configuration (sampling rate, exporter endpoint)"],"output_types":["Structured log entries with tool execution details","OpenTelemetry traces with full execution context","Metrics (latency, success rate, error count)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":31,"verified":false,"data_access_risk":"high","permissions":["Node.js 18+ for native WebSocket and stream handling","MCP server compatible with protocol version 2024-11-05 or later","For stdio transport: direct process spawning capability","For SSE/WebSocket: network connectivity to MCP server endpoint","Zod 3.22+ for schema validation","JSON Schema-compliant tool definitions from MCP servers","TypeScript 4.9+ for type inference from translated schemas","Multiple MCP tools or servers to benefit from batching/parallelization","Batch execution configuration (parallel vs. sequential, aggregation strategy)","Cache storage backend (in-memory, Redis, or Mastra's memory system)"],"failure_modes":["No built-in request batching — each tool call is a separate JSON-RPC message, adding latency for high-frequency operations","Transport-specific limitations: stdio transport limited to local processes, SSE requires HTTP/1.1 compatibility, WebSocket requires persistent connection support","Capability negotiation happens once at initialization — dynamic capability changes require reconnection","No built-in caching of tool schemas — repeated tool discovery queries hit the server each time","Schema translation is one-directional (MCP → Mastra) — cannot export Mastra tools as MCP servers without additional wrapper code","Complex nested schemas with conditional properties may lose semantic information during translation","Runtime validation adds ~5-15ms per tool invocation for complex schemas","No automatic schema versioning — breaking changes in MCP server schemas require manual migration","Parallel execution adds complexity to error handling — partial failures must be handled explicitly","Batching is limited by MCP server support — not all servers support batch operations","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.49,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"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-06-17T09:51:03.578Z","last_scraped_at":"2026-05-03T14:00:15.503Z","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=mastra-mcp","compare_url":"https://unfragile.ai/compare?artifact=mastra-mcp"}},"signature":"BzY+XeArLncpTYYHR1IKp0wc+qlgUq4XtgPeqSgWz+6UtBUeYRLFbqgwIbnXTUhD/dXlCNdOkHqJpL7rPvHwCQ==","signedAt":"2026-06-20T10:51:28.104Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mastra-mcp","artifact":"https://unfragile.ai/mastra-mcp","verify":"https://unfragile.ai/api/v1/verify?slug=mastra-mcp","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"}}