{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-metorial-metorial","slug":"mcp-metorial-metorial","name":"metorial","type":"mcp","url":"https://github.com/metorial/metorial","page_url":"https://unfragile.ai/mcp-metorial-metorial","categories":["mcp-servers"],"tags":["agent","agentic-ai","agentic-workflow","container","docker","mcp","modelcontextprotocol","security"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-metorial-metorial__cap_0","uri":"capability://automation.workflow.mcp.server.hosting.and.lifecycle.management.with.dual.execution.modes","name":"mcp server hosting and lifecycle management with dual execution modes","description":"Metorial hosts MCP servers via two distinct execution paths: managed Lambda-style functions running on Deno runtime for custom servers, or HTTP-based remote server integration for existing MCP implementations. The platform handles server versioning, deployment, and lifecycle events through a unified management API that abstracts over both execution modes, enabling developers to deploy code once and connect multiple AI clients without infrastructure management.","intents":["Deploy custom MCP servers without managing containers or serverless infrastructure","Integrate existing HTTP-based MCP servers into a unified management platform","Version and publish MCP servers to a community marketplace","Scale MCP server capacity based on client demand without manual intervention"],"best_for":["Teams building custom MCP servers who want managed hosting","Organizations integrating multiple MCP servers from different sources","Open-source maintainers publishing tools to the MCP ecosystem"],"limitations":["Managed servers limited to Deno runtime — no native Python, Go, or Rust execution","Remote server integration requires HTTP/HTTPS endpoints with MCP protocol compliance","Cold start latency for managed Lambda functions may impact real-time use cases","Server versioning system requires explicit version tagging; no automatic rollback on failure"],"requires":["Docker and Docker Compose for self-hosted deployments","Deno runtime (bundled in managed execution environment)","MCP protocol-compliant server code (TypeScript/JavaScript or HTTP-compatible)","PostgreSQL database for metadata and session state"],"input_types":["TypeScript/JavaScript source code for managed servers","HTTP endpoint URLs for remote servers","Server configuration metadata (name, version, description)"],"output_types":["Deployed MCP server instance with unique endpoint","Server metadata and versioning records","Marketplace listing with installation instructions"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_1","uri":"capability://tool.use.integration.real.time.bidirectional.session.management.with.multiple.transport.protocols","name":"real-time bidirectional session management with multiple transport protocols","description":"Metorial manages persistent sessions between MCP clients and servers using WebSocket, Server-Sent Events (SSE), or HTTP streaming transports, with automatic connection state tracking and message routing. The session layer (localSession.go, remoteSession.go) abstracts transport differences, enabling clients to switch protocols transparently while maintaining message ordering and delivery guarantees across distributed execution engines.","intents":["Establish persistent connections between AI models and MCP servers without managing transport details","Route MCP messages reliably across multiple execution engines in a distributed setup","Handle connection failures and reconnection logic automatically","Support multiple concurrent clients connecting to the same MCP server instance"],"best_for":["AI agents requiring long-lived connections to tool servers","Teams deploying MCP infrastructure across multiple availability zones","Applications needing fallback transport mechanisms (WebSocket → SSE → HTTP polling)"],"limitations":["Message ordering guarantees only within a single session; cross-session consistency requires application-level coordination","SSE transport is unidirectional (server-to-client only) — requires HTTP POST for client-to-server messages","WebSocket connections may be dropped by proxies/firewalls; SSE fallback adds latency","Session state stored in-memory by default — requires external persistence for multi-instance deployments"],"requires":["WebSocket support in client and network infrastructure, or HTTP/1.1+ for SSE fallback","Redis or similar for distributed session state (if using multiple engine instances)","gRPC connectivity between API gateway and MCP engine service"],"input_types":["MCP protocol messages (JSON-RPC 2.0 format)","Session initialization parameters (server ID, client credentials)","Transport preference headers (WebSocket, SSE, HTTP streaming)"],"output_types":["Bidirectional message stream with delivery confirmation","Session metadata (ID, creation time, transport type, client/server identifiers)","Connection state events (connected, disconnected, error)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_10","uri":"capability://automation.workflow.environment.variable.templating.and.configuration.generation","name":"environment variable templating and configuration generation","description":"Metorial includes configuration generation tooling (generate.ts, type.ts) that templates environment variables for different deployment environments (development, staging, production) and generates type-safe configuration objects. The system validates required variables, provides defaults for optional settings, and generates TypeScript types for configuration access, reducing configuration errors and enabling IDE autocomplete.","intents":["Generate environment-specific configurations without manual file editing","Validate required configuration variables before deployment","Enable type-safe configuration access in application code","Share configuration templates across team members"],"best_for":["Teams managing multiple deployment environments","Organizations with strict configuration management requirements","Developers wanting type-safe configuration access"],"limitations":["Configuration generation requires Node.js tooling — not suitable for pure Docker deployments","Secrets must be provided as environment variables — no built-in secret management (requires Vault, AWS Secrets Manager)","Type generation is TypeScript-only — other languages require manual schema definition","No built-in validation for complex configuration constraints (e.g., port ranges, URL formats)"],"requires":["Node.js 18+ with npm or bun package manager","TypeScript compiler for type generation","Environment variables set in .env file or shell"],"input_types":["Configuration schema definition (TypeScript types)","Environment variables (.env file or shell exports)","Deployment environment identifier (dev, staging, prod)"],"output_types":["Generated .env file with templated values","TypeScript configuration types for IDE autocomplete","Validation report with missing or invalid variables"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_11","uri":"capability://automation.workflow.ci.cd.pipeline.with.automated.testing.and.containerized.builds","name":"ci/cd pipeline with automated testing and containerized builds","description":"Metorial includes GitHub Actions workflows (build-api.yml) that automate testing, building, and publishing Docker images on every commit. The pipeline runs unit tests, builds Docker containers, pushes to registry, and can trigger deployments. The build system uses Turbo for monorepo optimization, caching dependencies and build artifacts to reduce CI/CD duration.","intents":["Automatically test code changes before merging to main branch","Build and publish Docker images for each release","Ensure consistent builds across development and production environments","Reduce manual deployment steps and human error"],"best_for":["Teams using GitHub for version control","Organizations requiring automated testing and deployment","Projects with multiple services (monorepo) needing coordinated builds"],"limitations":["GitHub Actions workflows are GitHub-specific — requires migration for GitLab, Bitbucket, or self-hosted Git","Docker image builds require Docker registry credentials — must be securely stored as GitHub Secrets","Turbo caching requires consistent environment — may fail with non-deterministic builds","No built-in rollback mechanism — failed deployments require manual intervention"],"requires":["GitHub repository with Actions enabled","Docker registry credentials (Docker Hub, ECR, GCR, etc.)","Turbo configuration (turbo.json) for monorepo optimization"],"input_types":["Git commits with code changes","Pull requests for code review","Git tags for release triggers"],"output_types":["Test results and coverage reports","Built Docker images pushed to registry","Deployment status and logs"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_12","uri":"capability://automation.workflow.distributed.execution.engine.with.local.and.remote.server.support","name":"distributed execution engine with local and remote server support","description":"Metorial's MCP engine (written in Go) manages execution of both local managed servers (Deno-based Lambda functions) and remote HTTP-based servers through separate session implementations (localSession.go, remoteSession.go). The engine handles protocol translation, message routing, error handling, and connection lifecycle management, with gRPC-based manager service coordinating across multiple engine instances for horizontal scaling.","intents":["Execute MCP servers in isolated Deno runtime environments","Integrate existing HTTP-based MCP servers without modification","Scale MCP execution horizontally across multiple machines","Handle failures and reconnections transparently"],"best_for":["High-throughput MCP deployments requiring horizontal scaling","Organizations with existing HTTP-based MCP servers","Teams needing isolation between MCP server executions"],"limitations":["Local server execution limited to Deno runtime — no native Python, Go, or Rust support","Remote server integration requires HTTP/HTTPS endpoints — no support for Unix sockets or other transports","Engine coordination via gRPC requires network connectivity — no offline mode","No built-in resource limits (CPU, memory) per server — requires external container orchestration (Kubernetes) for enforcement"],"requires":["Go 1.19+ for engine compilation","Deno runtime for managed server execution","PostgreSQL for session state persistence","gRPC connectivity between engine instances"],"input_types":["Server configuration (type: local or remote, code or endpoint)","MCP protocol messages","Session initialization parameters"],"output_types":["Execution results (tool outputs, errors)","Session state updates","Connection status events"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_2","uri":"capability://safety.moderation.oauth.2.0.provider.integration.with.oidc.discovery.and.token.management","name":"oauth 2.0 provider integration with oidc discovery and token management","description":"Metorial implements a provider OAuth system that discovers OIDC endpoints, manages token lifecycle (acquisition, refresh, revocation), and injects provider credentials into MCP server execution contexts. The OAuth layer supports both standard OIDC implementations and custom OAuth flows, with token storage encrypted in the database and automatic refresh before expiration to ensure uninterrupted server access to protected resources.","intents":["Authenticate MCP servers against third-party APIs (GitHub, Google, Slack, etc.) without hardcoding credentials","Manage OAuth token lifecycle automatically, including refresh and revocation","Support custom OAuth providers beyond standard OIDC implementations","Inject provider credentials into server execution environment securely"],"best_for":["MCP servers that need to access protected APIs on behalf of users","Teams integrating with 600+ SaaS platforms requiring OAuth authentication","Organizations with custom OAuth providers or legacy authentication systems"],"limitations":["Token refresh requires background job infrastructure — no built-in scheduler, requires external cron/queue system","OIDC discovery assumes standard endpoint paths (.well-known/openid-configuration) — custom providers may require manual configuration","Token storage encrypted at rest but decrypted in-memory during execution — vulnerable to memory dumps","No built-in support for OAuth 2.0 Device Flow or PKCE for native mobile clients"],"requires":["OAuth 2.0 provider with OIDC discovery endpoint or manual configuration","Database encryption key for token storage (environment variable)","Background job processor for token refresh (e.g., Bull, RabbitMQ, or custom implementation)"],"input_types":["OAuth provider configuration (client ID, client secret, discovery URL)","User authorization code from OAuth provider","Refresh token (for token renewal)"],"output_types":["Access token injected into server environment variables","Token metadata (expiration time, scopes, provider)","Refresh token stored securely in database"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_3","uri":"capability://search.retrieval.mcp.marketplace.discovery.installation.and.publishing.system","name":"mcp marketplace discovery, installation, and publishing system","description":"Metorial provides a searchable marketplace (marketplace application) where developers publish MCP servers and users discover/install them with one-click integration. The marketplace indexes server metadata (name, description, capabilities, version), handles installation by creating server instances, and manages server ratings/reviews. Publishing requires version tagging and metadata validation, with automatic indexing for discoverability.","intents":["Discover community-built MCP servers without searching GitHub or documentation","Install MCP servers into your workspace with a single action","Publish custom MCP servers to reach other developers","Search for servers by capability, provider, or use case"],"best_for":["Individual developers building MCP tools for the ecosystem","Teams evaluating pre-built MCP servers before custom development","Organizations wanting to share internal MCP servers across teams"],"limitations":["Marketplace search is text-based only — no semantic capability matching or filtering by supported models","No built-in version compatibility checking — users must manually verify server version compatibility","Publishing requires manual version tagging; no automated semantic versioning or changelog generation","No built-in server rating/review system for quality assessment (mentioned as future feature)"],"requires":["Metorial account with publisher permissions","Server metadata (name, description, version, author, license)","Published server endpoint (managed or remote HTTP)"],"input_types":["Server metadata (JSON or form input)","Server code/endpoint URL","Version tag (semantic versioning recommended)"],"output_types":["Marketplace listing with installation link","Server metadata indexed for search","Installation instructions and usage documentation"],"categories":["search-retrieval","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_4","uri":"capability://automation.workflow.dashboard.based.mcp.server.configuration.and.monitoring","name":"dashboard-based mcp server configuration and monitoring","description":"Metorial includes a web-based dashboard (dashboard application) for managing MCP servers, viewing real-time session metrics, configuring OAuth providers, and monitoring execution logs. The dashboard uses Vite-based frontend build system with microfrontend architecture, enabling modular UI components that communicate with the REST API backend for server state management and observability.","intents":["Visually configure MCP servers without editing configuration files","Monitor active sessions and message throughput in real-time","View server logs and debug execution issues","Manage OAuth provider credentials through a UI"],"best_for":["Non-technical users managing MCP infrastructure","Teams needing visibility into server health and performance","Developers debugging MCP server behavior during development"],"limitations":["Dashboard is read-only for some metrics — bulk operations (e.g., restart all servers) require API calls","Real-time metrics require WebSocket connection; falls back to polling with 5-10 second latency","No built-in alerting system — requires external monitoring tools (Datadog, New Relic) for production alerts","Microfrontend architecture adds complexity; module loading failures can cascade to UI"],"requires":["Modern web browser (Chrome, Firefox, Safari, Edge)","Network access to Metorial API endpoint","Authentication credentials (OAuth or API key)"],"input_types":["Server configuration parameters (name, version, environment variables)","OAuth provider credentials","Session filters (date range, server ID, client ID)"],"output_types":["Server configuration updates","Session metrics (message count, latency, error rate)","Execution logs with filtering and search"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_5","uri":"capability://tool.use.integration.multi.provider.mcp.server.integration.with.schema.based.function.calling","name":"multi-provider mcp server integration with schema-based function calling","description":"Metorial abstracts MCP protocol details and enables any AI model (OpenAI, Anthropic, Ollama, etc.) to call MCP server functions through a unified schema-based interface. The platform translates MCP resource/tool definitions into provider-specific function calling formats, handles parameter validation, and manages response marshaling back to the MCP protocol, enabling seamless tool use across different AI model APIs.","intents":["Connect Claude, GPT-4, or open-source models to the same MCP servers without code changes","Automatically translate between MCP tool schemas and provider-specific function calling formats","Validate function parameters before execution to prevent runtime errors","Support streaming responses from MCP tools to AI models"],"best_for":["Teams using multiple AI models and wanting consistent tool integration","Organizations building AI agents that need provider flexibility","Developers creating MCP servers that should work with any AI model"],"limitations":["Schema translation adds ~50-100ms latency per function call due to format conversion","Some provider-specific features (e.g., OpenAI's parallel function calling) may not map cleanly to MCP schema","Parameter validation only checks type and required fields — no semantic validation (e.g., valid email format)","Streaming responses require provider support; non-streaming providers receive buffered responses"],"requires":["MCP server with properly defined resources and tools in MCP schema","AI model API key for target provider (OpenAI, Anthropic, Ollama, etc.)","Network connectivity to both MCP server and AI model API"],"input_types":["MCP tool schema (JSON with name, description, parameters)","Function call request from AI model (provider-specific format)","Function parameters (JSON object)"],"output_types":["Provider-specific function calling format (OpenAI function_call, Anthropic tool_use, etc.)","Function execution result (JSON)","Error messages with provider-specific formatting"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_6","uri":"capability://automation.workflow.containerized.self.hosted.deployment.with.docker.compose.orchestration","name":"containerized self-hosted deployment with docker compose orchestration","description":"Metorial provides production-ready Docker Compose configuration (metorial.docker-compose.yml, engine-unified.Dockerfile) enabling self-hosted deployment of the entire platform including API services, MCP engine, database, caching layer, and frontend applications. The deployment includes environment variable templating, volume management for persistence, and networking configuration, allowing organizations to run Metorial on-premises or in private cloud environments.","intents":["Deploy Metorial to private infrastructure without cloud vendor lock-in","Run MCP servers in isolated environments with network policies","Maintain full control over data and credentials in regulated industries","Scale MCP infrastructure horizontally by running multiple engine instances"],"best_for":["Enterprises with data residency requirements (HIPAA, GDPR, SOC 2)","Organizations with existing Kubernetes or Docker infrastructure","Teams wanting to avoid cloud provider dependencies"],"limitations":["Docker Compose suitable for development/small deployments only — production requires Kubernetes or similar orchestration","Multi-instance deployments require external Redis for session state sharing; no built-in distributed state management","Database migrations must be run manually before deployment; no automatic schema versioning","Monitoring and logging require external tools (ELK, Prometheus) — no built-in observability stack"],"requires":["Docker 20.10+ and Docker Compose 2.0+","PostgreSQL 14+ (can be containerized or external)","Redis 6.0+ for caching and session state (optional but recommended)","Minimum 4GB RAM and 20GB disk space for single-instance deployment"],"input_types":["Environment variables (.env file with API keys, database credentials)","Docker Compose configuration (YAML)","Custom MCP server code (mounted as volumes)"],"output_types":["Running Metorial platform accessible at configured hostname","Persistent database with server metadata and session state","Container logs for debugging and monitoring"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_7","uri":"capability://tool.use.integration.grpc.based.inter.service.communication.with.protocol.buffer.serialization","name":"grpc-based inter-service communication with protocol buffer serialization","description":"Metorial uses gRPC and protocol buffers (manager.pb.go, manager_grpc.pb.go) for high-performance communication between API gateway and MCP execution engines, enabling efficient message serialization, bidirectional streaming, and service discovery. The gRPC manager service handles session lifecycle, message routing, and connection state management across distributed engine instances with automatic load balancing.","intents":["Route MCP messages efficiently between API gateway and execution engines with low latency","Support bidirectional streaming for real-time session updates","Enable horizontal scaling of execution engines with automatic load balancing","Ensure type-safe inter-service communication with protocol buffer contracts"],"best_for":["Teams deploying Metorial across multiple machines or availability zones","High-throughput MCP deployments requiring sub-100ms message latency","Organizations with existing gRPC infrastructure and expertise"],"limitations":["gRPC requires HTTP/2 support — may not work behind older proxies or load balancers","Protocol buffer schema changes require coordination across services; no built-in versioning","gRPC debugging requires specialized tools (grpcurl, Postman gRPC support) — less accessible than REST","Connection pooling and keepalive configuration requires tuning for production deployments"],"requires":["gRPC runtime (Go for engine, Node.js for API gateway)","Protocol buffer compiler (protoc) for schema generation","HTTP/2 capable network infrastructure"],"input_types":["Protocol buffer message definitions (.proto files)","Session initialization requests (gRPC message)","MCP protocol messages (wrapped in gRPC envelope)"],"output_types":["gRPC streaming responses with session updates","Connection state events (connected, disconnected, error)","Message delivery confirmation"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_8","uri":"capability://data.processing.analysis.database.backed.session.and.event.persistence.with.prisma.orm","name":"database-backed session and event persistence with prisma orm","description":"Metorial uses Prisma ORM with PostgreSQL to persist session state, message history, execution events, and server metadata. The data layer (session.go, message.go, event.go, run.go) provides type-safe database access with automatic migrations, connection pooling, and query optimization. Session data includes connection metadata, message ordering, and event timestamps for audit trails and debugging.","intents":["Persist MCP session state across server restarts without losing message history","Query historical sessions for debugging and audit purposes","Track execution events (tool calls, errors, completions) for observability","Enable session replay and forensic analysis of MCP interactions"],"best_for":["Production deployments requiring session durability and audit trails","Teams needing to debug MCP server behavior through historical data","Regulated industries requiring message logging and compliance records"],"limitations":["Prisma ORM adds ~10-20ms latency per database query compared to raw SQL","Message history storage grows unbounded — requires manual cleanup or archival strategy","Database connection pooling requires tuning for high-concurrency deployments (100+ concurrent sessions)","No built-in data retention policies — organizations must implement their own archival"],"requires":["PostgreSQL 12+ with network access from API and engine services","Prisma client library (included in package.json)","Database credentials and connection string in environment variables"],"input_types":["Session initialization data (client ID, server ID, transport type)","MCP protocol messages (JSON-RPC format)","Execution events (tool calls, errors, completions)"],"output_types":["Session records with metadata (creation time, duration, message count)","Message history with ordering and timestamps","Event logs with execution details and error traces"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-metorial-metorial__cap_9","uri":"capability://tool.use.integration.rest.api.gateway.with.request.routing.and.response.transformation","name":"rest api gateway with request routing and response transformation","description":"Metorial exposes a REST API (rest.ts) that handles client requests for server management, session creation, OAuth configuration, and marketplace operations. The API gateway routes requests to appropriate backend services (MCP engine, marketplace, authentication), transforms responses to consistent JSON format, and implements request validation and error handling. The API supports both synchronous operations (server configuration) and asynchronous operations (server deployment) with status polling.","intents":["Programmatically manage MCP servers and sessions via REST API","Integrate Metorial with external tools and CI/CD pipelines","Automate server deployment and configuration management","Query server status and session metrics"],"best_for":["Teams building custom integrations with Metorial","CI/CD pipelines automating MCP server deployment","Third-party tools and dashboards consuming Metorial data"],"limitations":["REST API is synchronous for most operations — long-running deployments require polling for completion status","No built-in rate limiting or quota management — requires external API gateway (Kong, AWS API Gateway) for production","API versioning requires URL path changes (e.g., /v1/, /v2/) — no content negotiation support","Error responses lack structured error codes — clients must parse error messages as strings"],"requires":["HTTP client library (curl, axios, requests, etc.)","API authentication (OAuth token or API key)","Network access to Metorial API endpoint"],"input_types":["JSON request body with server configuration or session parameters","URL path parameters (server ID, session ID)","Query parameters (filters, pagination)"],"output_types":["JSON response with server metadata, session status, or operation results","HTTP status codes (200, 201, 400, 401, 404, 500)","Error responses with error message and details"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":46,"verified":false,"data_access_risk":"high","permissions":["Docker and Docker Compose for self-hosted deployments","Deno runtime (bundled in managed execution environment)","MCP protocol-compliant server code (TypeScript/JavaScript or HTTP-compatible)","PostgreSQL database for metadata and session state","WebSocket support in client and network infrastructure, or HTTP/1.1+ for SSE fallback","Redis or similar for distributed session state (if using multiple engine instances)","gRPC connectivity between API gateway and MCP engine service","Node.js 18+ with npm or bun package manager","TypeScript compiler for type generation","Environment variables set in .env file or shell"],"failure_modes":["Managed servers limited to Deno runtime — no native Python, Go, or Rust execution","Remote server integration requires HTTP/HTTPS endpoints with MCP protocol compliance","Cold start latency for managed Lambda functions may impact real-time use cases","Server versioning system requires explicit version tagging; no automatic rollback on failure","Message ordering guarantees only within a single session; cross-session consistency requires application-level coordination","SSE transport is unidirectional (server-to-client only) — requires HTTP POST for client-to-server messages","WebSocket connections may be dropped by proxies/firewalls; SSE fallback adds latency","Session state stored in-memory by default — requires external persistence for multi-instance deployments","Configuration generation requires Node.js tooling — not suitable for pure Docker deployments","Secrets must be provided as environment variables — no built-in secret management (requires Vault, AWS Secrets Manager)","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.5479927608627163,"quality":0.35,"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:38.364Z","last_commit":"2026-05-03T14:20:06Z"},"community":{"stars":3257,"forks":357,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-metorial-metorial","compare_url":"https://unfragile.ai/compare?artifact=mcp-metorial-metorial"}},"signature":"gI6DrOi38hUKCBdoDXq6lXCj3t9R35GCWd1oSyO+rHtgkFGZaTsJ1OYyJ2lJu2oUlM6PkuXh8PYBzAXVvpF3BQ==","signedAt":"2026-06-20T15:04:18.518Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-metorial-metorial","artifact":"https://unfragile.ai/mcp-metorial-metorial","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-metorial-metorial","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"}}