{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-mcp","slug":"pypi-mcp","name":"mcp","type":"mcp","url":"https://pypi.org/project/mcp/","page_url":"https://unfragile.ai/pypi-mcp","categories":["mcp-servers"],"tags":["automation","git","llm","mcp"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-mcp__cap_0","uri":"capability://tool.use.integration.decorator.based.mcp.server.framework.with.automatic.function.wrapping","name":"decorator-based mcp server framework with automatic function wrapping","description":"FastMCP provides a high-level decorator API (@mcp.tool(), @mcp.resource(), @mcp.prompt()) that automatically wraps Python functions into MCP protocol handlers. The framework uses Python type annotations to inject context (e.g., via @mcp.use_context), automatically serializes return values into MCP result types, and generates JSON-RPC 2.0 compliant messages without requiring manual handler construction. This eliminates boilerplate compared to the low-level Server API which requires explicit handler registration and result type construction.","intents":["Build an MCP server exposing Python functions as tools without writing protocol boilerplate","Quickly prototype LLM-integrated applications with minimal MCP knowledge","Automatically generate OpenAPI-compatible schemas from function signatures for tool discovery"],"best_for":["Python developers building LLM agents and Claude integrations","Teams prototyping MCP servers with rapid iteration cycles","Non-infrastructure engineers who want MCP without protocol details"],"limitations":["Abstraction layer adds ~50-100ms overhead per request due to automatic type wrapping and validation","Limited control over low-level protocol negotiation and session management compared to Server API","Type annotation-based context injection may be opaque for complex dependency scenarios"],"requires":["Python 3.9+","mcp package from PyPI","Understanding of Python type hints and decorators"],"input_types":["Python function signatures with type annotations","Pydantic models for structured input validation"],"output_types":["JSON-RPC 2.0 MCP protocol messages","Automatically serialized tool results, resources, and prompts"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_1","uri":"capability://tool.use.integration.low.level.handler.based.mcp.server.with.explicit.protocol.control","name":"low-level handler-based mcp server with explicit protocol control","description":"The Server class (src/mcp/server/lowlevel/server.py) provides a constructor-based API where developers register handler functions via parameters like on_list_tools=..., on_call_tool=..., on_read_resource=... This approach gives full control over JSON-RPC message construction, session lifecycle, and protocol negotiation. Handlers receive raw MCP request objects and must explicitly construct result types, enabling fine-grained control over error handling, streaming responses, and capability negotiation.","intents":["Build MCP servers with custom protocol behavior and advanced error handling","Implement streaming tool responses or progressive resource loading","Integrate MCP into existing Python applications with specific session management requirements"],"best_for":["Infrastructure engineers building production MCP deployments","Teams needing fine-grained control over protocol negotiation and session state","Applications requiring custom authentication or authorization logic"],"limitations":["Requires explicit construction of MCP result types (ToolResult, ResourceContents, etc.) for each handler","No automatic type validation or schema generation — developers must validate inputs manually","Higher cognitive load due to explicit JSON-RPC message handling and session management"],"requires":["Python 3.9+","mcp package from PyPI","Understanding of MCP protocol specification and JSON-RPC 2.0"],"input_types":["Handler functions accepting MCP request objects","Raw JSON-RPC 2.0 message structures"],"output_types":["Explicitly constructed MCP result types (ToolResult, ResourceContents, PromptResult)","JSON-RPC 2.0 response messages with custom error handling"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_10","uri":"capability://automation.workflow.progress.notifications.and.streaming.response.support","name":"progress notifications and streaming response support","description":"The SDK supports progress notifications and streaming responses, allowing tools to report progress during long-running operations and stream partial results back to clients. Tools can emit ProgressNotification messages during execution, and clients can subscribe to these notifications to display progress to users. Streaming responses allow tools to return large results incrementally without buffering the entire response in memory.","intents":["Report progress during long-running tool operations (file processing, API calls, etc.)","Stream large results back to clients without buffering in memory","Build responsive LLM agents that can display progress and partial results to users"],"best_for":["Teams building tools that perform long-running operations (data processing, file uploads, etc.)","Developers creating responsive LLM interfaces that show progress to users","Applications streaming large results (logs, data exports, etc.) to clients"],"limitations":["Progress notifications require client-side subscription and event handling; no automatic UI updates","Streaming responses require transport support (STDIO and StreamableHTTP support streaming; SSE has limitations)","Progress tracking is application-specific; no standard progress format (percentage, bytes, items, etc.)"],"requires":["Python 3.9+","mcp package from PyPI","Transport that supports streaming (STDIO, StreamableHTTP)"],"input_types":["Progress updates (percentage, bytes processed, items completed, etc.)","Partial results to stream back to client"],"output_types":["ProgressNotification messages sent to clients","Streaming response chunks"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_11","uri":"capability://tool.use.integration.capability.negotiation.and.protocol.version.compatibility","name":"capability negotiation and protocol version compatibility","description":"The SDK implements MCP capability negotiation during the initialize handshake, allowing servers and clients to advertise their supported features and agree on a common protocol version. Servers declare which capabilities they support (tools, resources, prompts, sampling, etc.), and clients can query these capabilities to determine which features are available. This enables forward/backward compatibility — older clients can work with newer servers by only using supported features.","intents":["Negotiate protocol features between client and server during connection setup","Determine which MCP features are available on a server before attempting to use them","Maintain compatibility across different MCP SDK versions"],"best_for":["Teams deploying MCP servers that need to support multiple client versions","Developers building MCP clients that need to adapt to server capabilities","Infrastructure teams managing MCP deployments with version heterogeneity"],"limitations":["Capability negotiation adds ~50-100ms to connection setup time","No automatic fallback if a required capability is not supported; applications must handle missing capabilities","Capabilities are coarse-grained (e.g., 'tools' vs specific tool features); fine-grained feature detection not supported"],"requires":["Python 3.9+","mcp package from PyPI"],"input_types":["Server capability declarations (supported features, protocol version)","Client capability requirements"],"output_types":["Negotiated capability set (features both client and server support)","Protocol version agreement"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_12","uri":"capability://planning.reasoning.experimental.task.system.for.complex.multi.step.operations","name":"experimental task system for complex multi-step operations","description":"The SDK includes an experimental task system that allows servers to define complex, multi-step operations that clients can execute. Tasks are similar to tools but support more complex workflows with state management, branching, and progress tracking. This is an early-stage feature designed for future MCP extensions but is available for experimentation.","intents":["Define complex multi-step workflows that LLMs can execute","Implement stateful operations with branching and conditional logic","Experiment with advanced MCP features for future protocol versions"],"best_for":["Teams experimenting with advanced MCP features","Developers building complex workflows that don't fit the tool model","Early adopters willing to work with unstable APIs"],"limitations":["Experimental API; no stability guarantees between SDK versions","Limited documentation and examples available","Not all MCP clients support tasks; limited interoperability"],"requires":["Python 3.9+","mcp package from PyPI","Willingness to adapt code as the experimental API evolves"],"input_types":["Task definitions with steps and state","Task execution parameters"],"output_types":["Task execution results and state transitions"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_13","uri":"capability://data.processing.analysis.content.type.abstraction.for.structured.output.and.rich.formatting","name":"content type abstraction for structured output and rich formatting","description":"The SDK supports multiple content types (text, image, PDF, etc.) for tool results and resources, allowing servers to return richly formatted responses. Content types are abstracted behind a unified interface, enabling clients to handle different content types appropriately (render images, display PDFs, etc.). This enables tools to return structured, formatted output that LLMs and clients can interpret correctly.","intents":["Return richly formatted results from tools (images, PDFs, HTML, etc.)","Enable clients to render tool results appropriately based on content type","Support tools that generate structured output (charts, documents, etc.)"],"best_for":["Teams building tools that generate rich output (visualizations, documents, etc.)","Developers creating MCP clients that need to display diverse content types","Applications integrating MCP with UI frameworks that support rich content"],"limitations":["Content type support depends on client implementation; not all clients support all types","Large binary content (images, PDFs) requires streaming or chunking for efficiency","Content type negotiation is not automatic; servers must declare supported types"],"requires":["Python 3.9+","mcp package from PyPI"],"input_types":["Tool results with various content types (text, image, PDF, etc.)","Content type declarations"],"output_types":["Structured content objects with type information","Serialized content in appropriate format"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_2","uri":"capability://tool.use.integration.multi.transport.abstraction.layer.with.uniform.read.write.stream.interface","name":"multi-transport abstraction layer with uniform read/write stream interface","description":"The SDK abstracts transport mechanisms (STDIO, SSE, StreamableHTTP) behind a uniform (read_stream, write_stream) interface that carries SessionMessage objects. This allows server and client code to be transport-agnostic — the same handler logic works over STDIO for local development, SSE for browser clients, or StreamableHTTP for production deployments. The transport layer handles serialization/deserialization of JSON-RPC messages and manages connection lifecycle independently of application logic.","intents":["Deploy the same MCP server code across multiple transport mechanisms without refactoring","Switch from STDIO development to production HTTP deployment without changing handler code","Build MCP clients that work with servers using different transport protocols"],"best_for":["Teams deploying MCP servers across development, staging, and production environments","Developers building Claude Desktop integrations (STDIO) that need to scale to web clients (HTTP)","Infrastructure teams managing multiple MCP server instances with different connectivity requirements"],"limitations":["Transport abstraction adds ~20-50ms latency per message due to serialization/deserialization overhead","StreamableHTTP requires external session store (Redis, database) for resumability and event persistence","STDIO transport limited to local process communication; not suitable for remote deployments"],"requires":["Python 3.9+","mcp package from PyPI","For StreamableHTTP: external session store (Redis recommended) and DNS rebinding protection configuration"],"input_types":["SessionMessage objects (JSON-RPC 2.0 wrapped in MCP envelope)","Byte streams from transport mechanisms (STDIO pipes, HTTP request bodies, SSE streams)"],"output_types":["SessionMessage objects for application handlers","Serialized JSON-RPC messages sent over transport"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_3","uri":"capability://data.processing.analysis.pydantic.based.json.rpc.type.system.with.discriminated.unions.for.automatic.message.routing","name":"pydantic-based json-rpc type system with discriminated unions for automatic message routing","description":"The protocol layer (src/mcp/types.py) defines all MCP messages using Pydantic discriminated unions keyed on the 'method' field. This enables automatic validation and routing of incoming JSON-RPC messages to the correct handler without manual type checking. The type system provides compile-time safety (via type hints) and runtime validation (via Pydantic), ensuring malformed messages are rejected before reaching application handlers. All protocol messages (requests, responses, notifications) are strongly typed.","intents":["Validate incoming MCP protocol messages automatically without manual type checking","Route JSON-RPC requests to correct handlers based on method field with type safety","Catch protocol violations early with Pydantic validation errors"],"best_for":["Teams building robust MCP servers that need protocol compliance guarantees","Developers integrating MCP into systems where type safety is critical","Infrastructure teams deploying MCP servers that must reject malformed messages"],"limitations":["Pydantic validation adds ~10-20ms overhead per message for complex nested types","Discriminated union routing requires exact 'method' field matching; custom routing logic not supported","Type definitions are tightly coupled to MCP specification version; schema changes require SDK updates"],"requires":["Python 3.9+","mcp package from PyPI","Pydantic 2.0+ (included as dependency)"],"input_types":["JSON-RPC 2.0 message objects (as dicts or JSON strings)","Pydantic model instances"],"output_types":["Strongly typed MCP message objects (Request, Response, Notification)","Pydantic ValidationError for invalid messages"],"categories":["data-processing-analysis","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_4","uri":"capability://tool.use.integration.clientsession.api.for.making.mcp.requests.with.automatic.response.handling","name":"clientsession api for making mcp requests with automatic response handling","description":"The ClientSession class provides a high-level async API for making MCP requests (list_tools, call_tool, read_resource, etc.) with automatic response handling and error propagation. Developers call methods like await session.call_tool(name, arguments) and receive strongly-typed response objects without manually constructing JSON-RPC messages or handling protocol details. The API handles request/response correlation, timeout management, and server notification subscriptions.","intents":["Build LLM clients that call MCP tools without understanding JSON-RPC protocol details","Make concurrent MCP requests with automatic response correlation and error handling","Subscribe to server notifications and handle streaming responses from tools"],"best_for":["Python developers building LLM agents that consume MCP servers","Teams integrating MCP into existing Python applications","Developers prototyping Claude integrations that need to call remote tools"],"limitations":["Async-only API; no synchronous wrapper provided (requires asyncio event loop)","Request timeout handling is global; no per-request timeout configuration","Notification subscription requires manual event loop management; no built-in event bus"],"requires":["Python 3.9+","mcp package from PyPI","Async/await support and asyncio event loop"],"input_types":["Tool names and argument dictionaries","Resource URIs and request parameters","Prompt names and arguments"],"output_types":["Strongly typed response objects (ToolResult, ResourceContents, PromptResult)","Server notifications (ProgressNotification, etc.)"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_5","uri":"capability://code.generation.editing.automatic.function.metadata.extraction.and.json.schema.generation.for.tools","name":"automatic function metadata extraction and json schema generation for tools","description":"The SDK automatically extracts Python function signatures and type annotations to generate JSON schemas for tool parameters. When a function is decorated with @mcp.tool(), the framework inspects the function's signature, docstring, and type hints to construct a ToolDefinition with a JSON schema describing required/optional parameters, types, and descriptions. This schema is used by LLMs to understand how to call the tool without requiring manual schema definition.","intents":["Expose Python functions as LLM-callable tools with automatically generated parameter schemas","Generate OpenAPI-compatible schemas from function signatures for tool discovery","Validate tool arguments against the schema before calling the function"],"best_for":["Python developers building LLM tools who want schema generation without manual definition","Teams integrating existing Python libraries into MCP without schema rewriting","Developers building tool discovery systems that need to understand parameter requirements"],"limitations":["Schema generation relies on type hints; untyped functions generate minimal schema information","Complex types (Union, Optional, nested Pydantic models) may generate verbose or ambiguous schemas","Docstring parsing is basic; complex descriptions with formatting may not translate to schema descriptions"],"requires":["Python 3.9+","mcp package from PyPI","Type annotations on function parameters (required for useful schema generation)"],"input_types":["Python function objects with type annotations","Docstrings describing function behavior and parameters"],"output_types":["JSON schema objects describing tool parameters","ToolDefinition objects with name, description, and input schema"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_6","uri":"capability://tool.use.integration.context.injection.via.type.annotations.and.lifespan.management","name":"context injection via type annotations and lifespan management","description":"FastMCP uses Python type annotations to inject context objects (e.g., @mcp.use_context(RequestContext)) into tool functions. The framework maintains a context lifecycle tied to the request/response cycle, allowing tools to access request metadata, session information, and server state without explicit parameter passing. Lifespan hooks (@mcp.on_startup, @mcp.on_shutdown) manage resource initialization and cleanup across the server's lifetime.","intents":["Access request context (user identity, session ID, etc.) in tool functions without parameter passing","Initialize and cleanup server resources (database connections, API clients) with lifespan hooks","Share state across multiple tool invocations within a session"],"best_for":["Teams building stateful MCP servers that need per-request context","Developers integrating MCP with existing Python frameworks (FastAPI, Django) that use context patterns","Applications requiring authentication/authorization context in tool handlers"],"limitations":["Context injection via type annotations may be opaque for developers unfamiliar with Python dependency injection patterns","Lifespan management is global; no per-session resource initialization (requires external state store)","Context objects must be thread-safe if tools are called concurrently"],"requires":["Python 3.9+","mcp package from PyPI","Understanding of Python type annotations and context managers"],"input_types":["Type annotations on function parameters","Context manager objects implementing __aenter__ and __aexit__"],"output_types":["Injected context objects available in tool functions","Lifecycle events (startup, shutdown) for resource management"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_7","uri":"capability://memory.knowledge.resource.and.prompt.definition.with.dynamic.content.generation","name":"resource and prompt definition with dynamic content generation","description":"The SDK allows servers to expose resources (files, documents, data) and prompts (instruction templates) via @mcp.resource() and @mcp.prompt() decorators. Resources are defined with URIs and can return text or binary content; prompts are templates with arguments that LLMs can discover and use. Both are registered in the server's capability list and can be queried by clients, enabling LLMs to access external data and use pre-defined instruction templates without hardcoding them.","intents":["Expose files, documents, or data sources as MCP resources for LLM access","Define reusable prompt templates that LLMs can discover and instantiate with arguments","Build knowledge bases or documentation systems accessible to LLM agents"],"best_for":["Teams building LLM agents that need access to external documents or data","Developers creating prompt libraries that LLMs can discover and use","Applications integrating MCP with knowledge management or documentation systems"],"limitations":["Resource content is generated on-demand; no built-in caching (requires external cache layer)","Prompt templates are simple string substitution; no complex templating language support","Resource URIs must be unique; no built-in versioning or content negotiation"],"requires":["Python 3.9+","mcp package from PyPI","Resource content sources (files, databases, APIs)"],"input_types":["Resource URIs (strings identifying resources)","Prompt names and argument dictionaries"],"output_types":["Resource content (text or binary data)","Rendered prompt strings with arguments substituted"],"categories":["memory-knowledge","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_8","uri":"capability://safety.moderation.server.side.authentication.and.authorization.with.token.verification","name":"server-side authentication and authorization with token verification","description":"The SDK supports server-side authentication via token verification and authorization configuration. Servers can validate client credentials (API keys, OAuth tokens) before processing requests, and implement role-based access control (RBAC) to restrict which clients can access which tools/resources. The authorization layer integrates with the ServerSession to enforce permissions at the request level.","intents":["Authenticate MCP clients with API keys or OAuth tokens before allowing tool access","Implement role-based access control to restrict tool/resource access by client identity","Audit and log which clients accessed which tools for compliance"],"best_for":["Teams deploying MCP servers in multi-tenant environments","Applications requiring fine-grained access control over tools and resources","Infrastructure teams building MCP gateways with authentication requirements"],"limitations":["Authorization is per-request; no session-level caching of permissions (adds latency)","Token verification requires external identity provider (no built-in token generation)","RBAC implementation is custom; no standard role definitions provided"],"requires":["Python 3.9+","mcp package from PyPI","External identity provider (OAuth, API key store, etc.)"],"input_types":["Client credentials (API keys, OAuth tokens, etc.)","Authorization policies (role definitions, access rules)"],"output_types":["Authorization decisions (allow/deny)","Audit logs of client access"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-mcp__cap_9","uri":"capability://automation.workflow.streamablehttp.transport.with.session.resumability.and.event.persistence","name":"streamablehttp transport with session resumability and event persistence","description":"StreamableHTTP is a production-grade transport that uses HTTP streaming (chunked transfer encoding) for bidirectional communication. It includes built-in session management via StreamableHTTPSessionManager, event stores for message persistence, and resumability — if a connection drops, the client can reconnect and resume the session without losing state. The transport includes DNS rebinding protection and configurable security features for production deployments.","intents":["Deploy MCP servers over HTTP with automatic session resumability on connection loss","Build web-based MCP clients that maintain persistent connections to servers","Implement production-grade MCP deployments with event persistence and audit trails"],"best_for":["Teams deploying MCP servers to production with high availability requirements","Developers building web-based MCP clients that need resilient connections","Infrastructure teams managing MCP deployments with session persistence requirements"],"limitations":["Requires external session store (Redis, database) for event persistence and resumability","HTTP streaming adds ~100-200ms latency compared to STDIO due to HTTP overhead","DNS rebinding protection requires careful configuration; misconfiguration can block legitimate clients","Session resumability is limited to ~24 hours by default; older sessions are garbage collected"],"requires":["Python 3.9+","mcp package from PyPI","External session store (Redis recommended for performance)","HTTP server infrastructure (can use FastAPI, aiohttp, etc.)"],"input_types":["HTTP POST requests with JSON-RPC messages","Session IDs for resuming connections"],"output_types":["HTTP streaming responses with JSON-RPC messages","Session state persisted in external store"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":30,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","mcp package from PyPI","Understanding of Python type hints and decorators","Understanding of MCP protocol specification and JSON-RPC 2.0","Transport that supports streaming (STDIO, StreamableHTTP)","Willingness to adapt code as the experimental API evolves","For StreamableHTTP: external session store (Redis recommended) and DNS rebinding protection configuration","Pydantic 2.0+ (included as dependency)","Async/await support and asyncio event loop","Type annotations on function parameters (required for useful schema generation)"],"failure_modes":["Abstraction layer adds ~50-100ms overhead per request due to automatic type wrapping and validation","Limited control over low-level protocol negotiation and session management compared to Server API","Type annotation-based context injection may be opaque for complex dependency scenarios","Requires explicit construction of MCP result types (ToolResult, ResourceContents, etc.) for each handler","No automatic type validation or schema generation — developers must validate inputs manually","Higher cognitive load due to explicit JSON-RPC message handling and session management","Progress notifications require client-side subscription and event handling; no automatic UI updates","Streaming responses require transport support (STDIO and StreamableHTTP support streaming; SSE has limitations)","Progress tracking is application-specific; no standard progress format (percentage, bytes, items, etc.)","Capability negotiation adds ~50-100ms to connection setup time","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.52,"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-05-24T12:16:25.060Z","last_scraped_at":"2026-05-03T15:20:24.098Z","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=pypi-mcp","compare_url":"https://unfragile.ai/compare?artifact=pypi-mcp"}},"signature":"jT5f4ISLAqt65ISr6RDObjjictdUG24R0mrCWVkkb65J5JoQebOHY0rX3r+PhIiMrfUa4PKdJHTvlFWkscfsCQ==","signedAt":"2026-06-20T12:54:36.473Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-mcp","artifact":"https://unfragile.ai/pypi-mcp","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-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"}}