{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-rekog-labs-mcp-nest","slug":"mcp-rekog-labs-mcp-nest","name":"MCP-Nest","type":"mcp","url":"https://github.com/rekog-labs/MCP-Nest","page_url":"https://unfragile.ai/mcp-rekog-labs-mcp-nest","categories":["mcp-servers"],"tags":["llm","llms","mcp","mcp-nest","model-context-protocol","modelcontextprotocol","nestjs"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-rekog-labs-mcp-nest__cap_0","uri":"capability://tool.use.integration.decorator.based.tool.exposure.with.automatic.mcp.registration","name":"decorator-based tool exposure with automatic mcp registration","description":"Exposes NestJS service methods as MCP tools using @Tool() decorators that trigger metadata reflection at module initialization. McpRegistryDiscoveryService scans decorated methods, extracts parameter schemas via Zod validation, and auto-registers them in McpRegistryService without manual endpoint configuration. This integrates directly with NestJS dependency injection, allowing tools to access injected services, database connections, and application state.","intents":["I want to expose my existing NestJS service methods as AI-callable tools without writing boilerplate MCP server code","I need my AI agents to call backend business logic with type-safe input validation","I want to leverage NestJS dependency injection so my tools can access databases, caches, and other services"],"best_for":["NestJS backend developers building AI agent integrations","Teams migrating existing REST APIs to MCP protocol","Developers who want decorator-driven architecture matching NestJS conventions"],"limitations":["Decorators only work on NestJS service/controller methods — cannot expose arbitrary functions outside the DI container","Metadata reflection adds ~5-10ms per module initialization for large codebases with 100+ decorated methods","Zod schema inference from TypeScript types requires explicit schema definitions; implicit type inference not supported"],"requires":["NestJS 9.0+","TypeScript 4.5+","Zod for schema validation","@modelcontextprotocol/sdk package"],"input_types":["TypeScript method parameters with Zod schemas","Primitive types (string, number, boolean)","Complex objects with nested schema validation"],"output_types":["JSON-serializable return values","Promises (async methods)","Streaming responses via context.reportProgress()"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_1","uri":"capability://tool.use.integration.multi.transport.mcp.server.with.http.sse.streamable.http.and.stdio.support","name":"multi-transport mcp server with http+sse, streamable http, and stdio support","description":"Provides three transport mechanisms for MCP protocol communication: HTTP+SSE for web clients with real-time streaming, Streamable HTTP for stateless deployments, and STDIO for CLI/desktop applications. The transport layer abstracts the underlying @modelcontextprotocol/sdk server, routing all capability requests through McpExecutorService regardless of transport. Configuration is declarative via McpModule.forRoot(), allowing runtime selection of transports without code changes.","intents":["I need my MCP server to work with web-based AI clients that require Server-Sent Events for streaming","I want to deploy my MCP server in serverless/stateless environments without maintaining persistent connections","I need to support CLI tools and desktop applications that communicate via STDIO"],"best_for":["Teams deploying MCP servers across multiple client types (web, desktop, CLI)","Serverless/FaaS deployments requiring stateless HTTP transports","Organizations with existing Express or Fastify infrastructure"],"limitations":["HTTP+SSE requires persistent connections; not suitable for strict request-response architectures","Streamable HTTP adds latency for streaming responses due to chunked encoding overhead (~50-100ms per chunk)","STDIO transport limited to single-process execution; no built-in clustering or load balancing","Transport selection is global per McpModule instance; cannot mix transports for different capability groups"],"requires":["Express.js 4.18+ or Fastify 4.0+","Node.js 16+","@nestjs/platform-express or @nestjs/platform-fastify","Browser support for EventSource API (for HTTP+SSE clients)"],"input_types":["HTTP POST requests with JSON payloads","STDIO streams with newline-delimited JSON","Server-Sent Events (SSE) for streaming responses"],"output_types":["HTTP JSON responses","Server-Sent Event streams","STDIO output streams"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_10","uri":"capability://code.generation.editing.metadata.reflection.based.capability.discovery.at.module.initialization","name":"metadata reflection-based capability discovery at module initialization","description":"Scans NestJS services and controllers at module initialization time using TypeScript metadata reflection to discover @Tool(), @Resource(), and @Prompt() decorators. McpRegistryDiscoveryService extracts decorator metadata (name, description, schema) and registers capabilities in McpRegistryService without manual configuration. This enables zero-configuration capability exposure where decorators are the only required code.","intents":["I want to expose my NestJS services as MCP capabilities without writing configuration files or registration code","I need automatic discovery of decorated methods so new tools are available immediately after deployment","I want to keep capability definitions colocated with implementation code for maintainability"],"best_for":["Teams using NestJS with existing decorator-based architecture","Rapid development scenarios where minimizing boilerplate is critical","Monolithic applications with many services to expose as tools"],"limitations":["Metadata reflection requires TypeScript decorators; not available in plain JavaScript","Discovery is one-time at module initialization; runtime decorator additions are not discovered automatically","Reflection adds ~10-20ms per 100 decorated methods during module initialization","Decorator metadata is not type-checked at compile time; schema mismatches only detected at runtime"],"requires":["TypeScript with experimentalDecorators enabled in tsconfig.json","reflect-metadata library imported before module initialization","@Tool(), @Resource(), @Prompt() decorators on service methods"],"input_types":["TypeScript decorator metadata","Service method signatures"],"output_types":["Registered capabilities in McpRegistryService","Capability metadata (name, description, schema)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_11","uri":"capability://automation.workflow.stateful.vs.stateless.execution.mode.for.tool.handlers","name":"stateful vs stateless execution mode for tool handlers","description":"Supports both stateful (persistent context across invocations) and stateless (isolated execution per request) modes for tool handlers. Stateful mode maintains handler state in memory between tool calls, enabling tools to access previous results or maintain session context. Stateless mode executes each tool invocation in isolation, suitable for serverless/FaaS deployments. Mode is configured per McpModule, affecting all tools in that server instance.","intents":["I want my tools to maintain state across multiple invocations (e.g., conversation history, session data)","I need to deploy my MCP server in serverless environments where state cannot be persisted between requests","I want to choose between stateful and stateless execution based on deployment constraints"],"best_for":["Conversational AI agents requiring session context across tool calls","Serverless/FaaS deployments where stateless execution is required","Applications with different state requirements for different tool groups"],"limitations":["Stateful mode is not distributed; state is lost if the server restarts or scales horizontally","Stateless mode requires explicit state passing between tool invocations; cannot rely on handler-level state","No built-in state synchronization between multiple server instances; requires external state store","State cleanup is manual; no automatic garbage collection of stale session data"],"requires":["McpModule configuration specifying stateful or stateless mode","For stateful mode: in-memory state management or external state store","For stateless mode: explicit state passing via tool parameters"],"input_types":["Tool invocation requests","Optional: State context from previous invocations (stateless mode)"],"output_types":["Tool response","Updated state context (stateful mode)"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_12","uri":"capability://automation.workflow.platform.abstraction.supporting.express.and.fastify","name":"platform abstraction supporting express and fastify","description":"Abstracts the underlying HTTP platform (Express or Fastify) via NestJS platform adapters, allowing MCP-Nest to work with either framework without code changes. Transport layer is platform-agnostic, routing requests through the selected adapter. Configuration specifies the platform via @nestjs/platform-express or @nestjs/platform-fastify, enabling deployment flexibility without tool/resource/prompt modifications.","intents":["I want to use my preferred HTTP framework (Express or Fastify) with MCP-Nest without rewriting code","I need to migrate from Express to Fastify (or vice versa) without changing my MCP server implementation","I want to leverage framework-specific optimizations (Fastify's performance, Express's ecosystem)"],"best_for":["Teams with existing Express or Fastify infrastructure","Applications requiring framework flexibility for performance or ecosystem reasons","Deployments where framework choice is determined by operational constraints"],"limitations":["Platform selection is global per NestJS application; cannot mix Express and Fastify in the same app","Framework-specific features (middleware, plugins) are not abstracted; custom platform code may be needed","Performance characteristics differ between platforms; Fastify is generally faster but Express has larger ecosystem","Some transport features may have platform-specific behavior (e.g., SSE handling differs between Express and Fastify)"],"requires":["@nestjs/platform-express (for Express) or @nestjs/platform-fastify (for Fastify)","Express 4.18+ or Fastify 4.0+","Platform selection in NestFactory.create() call"],"input_types":["HTTP requests (platform-agnostic)","Platform-specific middleware/plugins"],"output_types":["HTTP responses (platform-agnostic)","MCP protocol messages"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_2","uri":"capability://tool.use.integration.dynamic.capability.registration.at.runtime.via.mcpregistryservice","name":"dynamic capability registration at runtime via mcpregistryservice","description":"Allows registration of tools, resources, and prompts after module initialization via McpRegistryService.register() API, enabling capabilities to be added/removed without server restart. Registered capabilities are stored in an in-memory registry and immediately available to MCP clients. This complements decorator-based discovery, supporting use cases like plugin systems, feature flags, or data-driven capability generation. The registry maintains isolation between multiple McpModule instances in the same application.","intents":["I want to dynamically add tools based on user permissions or feature flags without restarting the server","I need to build a plugin system where third-party code can register new capabilities at runtime","I want to generate capabilities from database records or API responses without hardcoding them"],"best_for":["Multi-tenant SaaS platforms with per-tenant capability sets","Plugin architectures where capabilities are loaded dynamically","Applications with feature flags controlling tool availability"],"limitations":["No persistence — dynamically registered capabilities are lost on server restart; requires external state store for durability","Registry is in-memory only; not suitable for distributed deployments without synchronization mechanism","No built-in conflict resolution if duplicate capability names are registered; last-write-wins behavior","Dynamic registration adds ~2-5ms per registration call; not optimized for bulk registration of 1000+ capabilities"],"requires":["McpModule already initialized","McpRegistryService injected into service/controller","Zod schema for capability input validation"],"input_types":["Tool definition objects with handler functions","Resource definitions with URI patterns","Prompt definitions with template strings"],"output_types":["Registration confirmation (void or boolean)","Capability metadata stored in registry"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_3","uri":"capability://safety.moderation.per.tool.authorization.with.guards.scopes.and.role.based.access.control","name":"per-tool authorization with guards, scopes, and role-based access control","description":"Implements fine-grained access control at the tool level using NestJS guards (@ToolGuards()), scope decorators (@ToolScopes()), and role decorators (@ToolRoles()). Authorization is evaluated before tool execution via McpExecutorService, with context passed from the MCP client (JWT tokens, OAuth credentials). Supports both global guards applied to all tools and per-tool overrides. Integrates with the optional McpAuthModule for OAuth 2.0 token validation and JWT verification.","intents":["I need to restrict certain tools to specific user roles or permission scopes","I want to validate OAuth 2.0 tokens from AI clients before allowing tool execution","I need to implement per-tool authorization policies without duplicating guard logic across services"],"best_for":["Multi-tenant applications where tools must be scoped to specific tenants or users","Enterprise deployments requiring role-based access control (RBAC)","OAuth 2.0 integrations with external identity providers"],"limitations":["Authorization evaluation adds ~5-15ms latency per tool invocation for token validation","Guard execution is sequential; complex authorization chains with multiple guards can add cumulative latency","No built-in attribute-based access control (ABAC); role/scope model is coarse-grained","McpAuthModule is in beta; OAuth 2.0 integration may have breaking changes in future releases"],"requires":["NestJS 9.0+","JWT library for token validation (e.g., jsonwebtoken)","Optional: McpAuthModule for OAuth 2.0 support","MCP client must pass authorization context (JWT token, OAuth credentials) in request headers or payload"],"input_types":["JWT tokens in Authorization header","OAuth 2.0 access tokens","Custom authorization context objects"],"output_types":["Authorization decision (allow/deny)","Execution context with user/tenant metadata"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_4","uri":"capability://memory.knowledge.resource.exposure.with.dynamic.uri.patterns.and.content.streaming","name":"resource exposure with dynamic uri patterns and content streaming","description":"Exposes backend resources (files, database records, API responses) as MCP resources using @Resource() decorators with URI pattern matching. Resources support dynamic content generation via handler functions and streaming large payloads via context.reportProgress(). The resource registry maintains a mapping of URI patterns to handlers, allowing clients to discover available resources and request specific ones by URI. Supports both static resources (fixed URIs) and parameterized resources (URI templates with variables).","intents":["I want to expose database records or API responses as discoverable resources for AI agents","I need to stream large files or datasets to MCP clients without loading them entirely into memory","I want to support parameterized resource URIs (e.g., /users/{id}) that map to dynamic content"],"best_for":["Applications exposing read-only data sources (databases, file systems, APIs) to AI agents","Systems with large datasets requiring streaming to avoid memory overhead","Multi-tenant applications where resources are scoped by tenant or user"],"limitations":["Resources are read-only by design; no built-in support for resource mutations or updates","URI pattern matching is simple string-based; no regex or complex pattern support","Streaming adds complexity for error handling; partial failures mid-stream cannot be recovered","No built-in caching; each resource request triggers handler execution, potentially expensive for frequently-accessed resources"],"requires":["@Resource() decorator on service methods","URI pattern string (e.g., '/users/{id}')","Handler function returning resource content or stream"],"input_types":["URI pattern strings","URI parameters (extracted from pattern variables)","Optional query parameters for filtering/pagination"],"output_types":["Resource content (text, JSON, binary)","Streaming responses via context.reportProgress()","Resource metadata (MIME type, size, last-modified)"],"categories":["memory-knowledge","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_5","uri":"capability://text.generation.language.prompt.template.exposure.with.dynamic.variable.substitution","name":"prompt template exposure with dynamic variable substitution","description":"Exposes reusable prompt templates as MCP prompts using @Prompt() decorators, allowing AI clients to discover and instantiate prompts with dynamic variable substitution. Prompts are stored in the registry with metadata (name, description, arguments schema) and can be retrieved by clients for use in their own LLM calls. Supports parameterized prompts where variables are substituted at retrieval time, enabling context-aware prompt generation without hardcoding values.","intents":["I want to expose domain-specific prompt templates that AI agents can use for consistent behavior","I need to provide prompts with dynamic variables that are filled in based on application state or user context","I want to centralize prompt management in my backend so changes propagate to all AI clients automatically"],"best_for":["Organizations standardizing on prompt templates across multiple AI agents","Applications where prompts need to be context-aware (tenant-specific, user-specific, data-driven)","Teams wanting to version and audit prompt changes centrally"],"limitations":["Prompts are templates only; no built-in LLM execution or evaluation","Variable substitution is simple string replacement; no conditional logic or complex templating","No versioning system; prompt updates immediately affect all clients without rollback capability","No usage analytics or prompt performance tracking built-in"],"requires":["@Prompt() decorator on service methods","Prompt name and description","Optional: Zod schema for prompt arguments"],"input_types":["Prompt template strings with variable placeholders","Argument objects for variable substitution"],"output_types":["Instantiated prompt string with variables substituted","Prompt metadata (name, description, arguments schema)"],"categories":["text-generation-language","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_6","uri":"capability://automation.workflow.progress.reporting.and.streaming.for.long.running.operations","name":"progress reporting and streaming for long-running operations","description":"Provides context.reportProgress() API for tools and resources to send real-time updates to MCP clients during long-running operations. Progress updates are streamed via the transport layer (HTTP+SSE, Streamable HTTP, or STDIO) without blocking the main response. Supports both text updates and structured progress objects with percentage/status information. Enables AI agents to monitor operation status and adjust behavior based on progress feedback.","intents":["I want to stream progress updates to AI clients while processing large datasets or long-running computations","I need to provide real-time feedback during tool execution so clients know the operation is still running","I want to send intermediate results or status updates without waiting for the final response"],"best_for":["Tools performing batch operations, data processing, or long-running computations","Applications requiring real-time feedback for user-facing AI agents","Systems where clients need to monitor operation status and potentially cancel long-running tasks"],"limitations":["Progress reporting is one-way; clients cannot send cancellation signals mid-operation","HTTP+SSE transport required for web clients; STDIO and Streamable HTTP have different streaming semantics","No built-in backpressure handling; rapid progress updates can overwhelm slow clients","Progress updates are not persisted; if client disconnects, update history is lost"],"requires":["context parameter passed to tool/resource handler","Transport layer supporting streaming (HTTP+SSE, Streamable HTTP, or STDIO)","MCP client capable of receiving streaming updates"],"input_types":["Progress message strings","Structured progress objects with percentage, status, metadata"],"output_types":["Streamed progress updates to MCP client","Final tool/resource response after progress reporting completes"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_7","uri":"capability://automation.workflow.multi.server.isolation.with.independent.registries.and.configurations","name":"multi-server isolation with independent registries and configurations","description":"Supports multiple McpModule instances in a single NestJS application, each with independent registries, configurations, and transport settings. Servers are isolated via unique identifiers and maintain separate capability namespaces, allowing different capability sets to be exposed on different ports or transports. This enables advanced deployment patterns like multi-tenant servers, feature-gated capability exposure, or A/B testing different tool configurations without application restart.","intents":["I want to run multiple MCP servers in one application with different capability sets for different clients","I need to expose different tools to different user groups or tenants without mixing registries","I want to test new tool configurations in parallel with production tools"],"best_for":["Multi-tenant SaaS platforms with per-tenant MCP servers","Organizations deploying multiple capability sets to different clients/teams","Advanced testing scenarios requiring parallel server instances"],"limitations":["Each McpModule instance consumes separate memory for registry and transport handlers; scaling to 10+ servers may impact memory usage","No built-in load balancing or traffic distribution between servers; clients must be configured to use specific server instances","Shared state between servers requires external coordination (database, cache); no built-in synchronization mechanism","Configuration is per-module; changing one server's configuration requires module re-initialization"],"requires":["Multiple McpModule.forRoot() calls with unique identifiers","Separate port/transport configuration per server","NestJS module composition supporting multiple module instances"],"input_types":["McpModule configuration objects","Unique server identifiers"],"output_types":["Independent MCP servers with isolated registries","Separate transport endpoints per server"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_8","uri":"capability://safety.moderation.exception.handling.and.custom.error.filtering.for.mcp.responses","name":"exception handling and custom error filtering for mcp responses","description":"Provides exception filters (NestJS pattern) for handling errors in tool/resource/prompt execution and converting them to MCP-compliant error responses. Filters can transform exceptions into user-friendly error messages, log errors for debugging, and prevent sensitive information leakage. Integrates with NestJS exception hierarchy, allowing developers to throw domain-specific exceptions that are automatically caught and formatted for MCP clients.","intents":["I want to catch tool execution errors and return meaningful error messages to AI clients","I need to prevent sensitive error details (stack traces, database errors) from leaking to clients","I want to log errors for debugging while returning sanitized responses to MCP clients"],"best_for":["Production deployments requiring error sanitization and security","Applications with complex error handling logic across multiple tools","Teams wanting centralized error handling without duplicating try-catch blocks"],"limitations":["Exception filters are evaluated after tool execution; cannot prevent resource-intensive operations from running","Error transformation is synchronous; async error handling requires explicit Promise rejection handling","No built-in error recovery or retry logic; filters only format errors for response","Filter order matters; multiple filters can conflict if not carefully ordered"],"requires":["NestJS ExceptionFilter implementation","Custom exception classes extending NestJS HttpException or generic Exception","Filter registration via @Catch() decorator or global filter binding"],"input_types":["Exceptions thrown during tool/resource/prompt execution","Error context (tool name, user, timestamp)"],"output_types":["MCP-formatted error responses","Sanitized error messages for clients","Structured error logs for debugging"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-rekog-labs-mcp-nest__cap_9","uri":"capability://data.processing.analysis.zod.schema.validation.for.tool.inputs.and.outputs","name":"zod schema validation for tool inputs and outputs","description":"Integrates Zod schema validation for type-safe tool input validation and output schema definition. Schemas are extracted from @Tool() decorators and used to validate incoming requests before handler execution. Output schemas document expected response types for MCP clients. Validation failures return structured error responses without invoking the tool handler, preventing invalid data from reaching business logic.","intents":["I want to validate tool inputs before execution to prevent invalid data from reaching my service logic","I need to document expected input/output types for AI clients so they can construct valid requests","I want type-safe tool definitions that catch schema mismatches at registration time, not runtime"],"best_for":["Applications requiring strict input validation for security or data integrity","Teams using TypeScript and wanting compile-time type safety for tools","Systems with complex input schemas (nested objects, conditional fields, custom validation)"],"limitations":["Zod schema definitions must be explicit; no automatic inference from TypeScript types","Schema validation adds ~2-5ms latency per tool invocation for complex schemas","Validation errors are returned to client; no built-in coercion or type conversion","Output schema validation is optional; not enforced at runtime unless explicitly configured"],"requires":["Zod library (zod package)","Explicit Zod schema definitions for tool inputs","Optional: Output schema definitions for documentation"],"input_types":["Zod schema objects (z.object(), z.string(), etc.)","Nested schemas with complex validation rules","Custom Zod refinements for domain-specific validation"],"output_types":["Validated input objects matching schema","Validation error responses with field-level details"],"categories":["data-processing-analysis","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":46,"verified":false,"data_access_risk":"high","permissions":["NestJS 9.0+","TypeScript 4.5+","Zod for schema validation","@modelcontextprotocol/sdk package","Express.js 4.18+ or Fastify 4.0+","Node.js 16+","@nestjs/platform-express or @nestjs/platform-fastify","Browser support for EventSource API (for HTTP+SSE clients)","TypeScript with experimentalDecorators enabled in tsconfig.json","reflect-metadata library imported before module initialization"],"failure_modes":["Decorators only work on NestJS service/controller methods — cannot expose arbitrary functions outside the DI container","Metadata reflection adds ~5-10ms per module initialization for large codebases with 100+ decorated methods","Zod schema inference from TypeScript types requires explicit schema definitions; implicit type inference not supported","HTTP+SSE requires persistent connections; not suitable for strict request-response architectures","Streamable HTTP adds latency for streaming responses due to chunked encoding overhead (~50-100ms per chunk)","STDIO transport limited to single-process execution; no built-in clustering or load balancing","Transport selection is global per McpModule instance; cannot mix transports for different capability groups","Metadata reflection requires TypeScript decorators; not available in plain JavaScript","Discovery is one-time at module initialization; runtime decorator additions are not discovered automatically","Reflection adds ~10-20ms per 100 decorated methods during module initialization","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.39290410445188073,"quality":0.5,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"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:22.065Z","last_scraped_at":"2026-05-03T14:23:34.856Z","last_commit":"2026-03-29T11:17:28Z"},"community":{"stars":638,"forks":105,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-rekog-labs-mcp-nest","compare_url":"https://unfragile.ai/compare?artifact=mcp-rekog-labs-mcp-nest"}},"signature":"y8AVAN0iKclGksD9Bu0qjZLzaVpBrlFwYnz/9eDR/Ys31nKrt1tWrrceV4ZYXehxM82nI0BJ69SlwqO66bvwBQ==","signedAt":"2026-06-21T23:01:24.740Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-rekog-labs-mcp-nest","artifact":"https://unfragile.ai/mcp-rekog-labs-mcp-nest","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-rekog-labs-mcp-nest","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"}}