{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-modelcontextprotocol-ext-apps","slug":"mcp-modelcontextprotocol-ext-apps","name":"ext-apps","type":"mcp","url":"https://github.com/modelcontextprotocol/ext-apps","page_url":"https://unfragile.ai/mcp-modelcontextprotocol-ext-apps","categories":["mcp-servers"],"tags":["ai","apps","mcp","mcp-apps","modelcontextprotocol","ui"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_0","uri":"capability://tool.use.integration.iframe.sandboxed.ui.rendering.with.postmessage.json.rpc.protocol","name":"iframe-sandboxed ui rendering with postmessage json-rpc protocol","description":"Renders HTML-based user interfaces in sandboxed iframes that communicate bidirectionally with MCP hosts via JSON-RPC 2.0 over postMessage. The protocol enforces strict message validation, capability negotiation during initialization, and secure request/response routing between View (iframe) and Host layers without direct DOM access or network exposure. Uses a three-party architecture where MCP servers declare ui:// URI resources that hosts fetch and render, with the View layer isolated from host context except through explicit RPC calls.","intents":["I need to render interactive charts, forms, or dashboards inline in Claude or ChatGPT without exposing the host to untrusted code","I want to build a UI that can call server tools and receive real-time updates while remaining sandboxed from the host application","I need to establish secure bidirectional communication between an embedded UI and an MCP host using a standardized protocol"],"best_for":["MCP server developers building interactive visualizations (maps, dashboards, data explorers)","Host application developers (Claude, ChatGPT) integrating third-party UI extensions","Teams building conversational AI products that need rich, interactive UI components"],"limitations":["No direct DOM access from View to Host — all communication must go through JSON-RPC message passing, adding latency per request","Iframe sandbox restrictions prevent certain browser APIs (localStorage, cookies, cross-origin requests) unless explicitly granted via sandbox attributes","Message size is limited by postMessage implementation (~1MB per message in most browsers); large data transfers require chunking or streaming patterns","No built-in persistence layer — Views must implement their own state management or request persistence from the server"],"requires":["TypeScript 4.5+ or JavaScript ES2020+ for View/Host implementation","Browser with postMessage support (all modern browsers)","MCP server implementing SEP-1865 specification for resource declaration","Host application with AppBridge integration to manage iframe lifecycle and message routing"],"input_types":["JSON-RPC 2.0 request messages (method, params, id)","HTML/CSS/JavaScript for UI resource content","Tool schemas and parameters from MCP server"],"output_types":["JSON-RPC 2.0 response messages (result or error)","Rendered HTML in iframe","Tool execution results from server","Log/message events from View to Host"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_1","uri":"capability://tool.use.integration.ui.resource.declaration.and.server.side.tool.ui.linkage","name":"ui resource declaration and server-side tool-ui linkage","description":"Enables MCP servers to declare interactive HTML resources using the ui:// URI scheme and link them to specific tools via _meta.ui.resourceUri metadata. The server SDK provides helper functions to register UI resources with MIME type text/html, versioning, and optional display mode hints (inline, modal, sidebar). When a tool is executed, the host automatically fetches the linked UI resource and renders it in an iframe, establishing the communication channel between the View and the server's tool execution context.","intents":["I want to attach a custom UI to a tool so it renders automatically when the tool is called","I need to declare multiple UI resources on my MCP server and version them independently","I want to control how my UI is displayed (inline vs modal vs sidebar) based on the host's capabilities"],"best_for":["MCP server developers building domain-specific tools (PDF viewers, map tools, data analyzers)","Teams migrating from REST APIs with custom UIs to MCP with standardized UI delivery","Developers building tools that benefit from rich visualization (charts, 3D models, interactive forms)"],"limitations":["UI resources must be valid HTML/CSS/JavaScript; no server-side templating or dynamic generation at declaration time","Tool-UI linkage is static — a tool can only link to one UI resource; multiple UIs require multiple tools","Display mode hints are advisory; hosts may ignore them based on their own layout constraints","No built-in mechanism for UI versioning conflicts — servers must manage version compatibility with older hosts"],"requires":["MCP server implementation (JavaScript/TypeScript or Python with MCP SDK)","HTML/CSS/JavaScript UI code as a string or file resource","Tool definition with _meta.ui.resourceUri field populated","Host that implements SEP-1865 specification for resource fetching"],"input_types":["Tool schema with _meta.ui.resourceUri string","HTML content as text/html MIME type","Display mode enum (inline, modal, sidebar, etc.)"],"output_types":["Registered UI resource accessible via ui:// URI","Tool metadata with UI linkage information","Rendered iframe in host application"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_10","uri":"capability://automation.workflow.logging.and.message.event.streaming.from.views.to.host","name":"logging and message event streaming from views to host","description":"Provides APIs for Views to send log messages and events to the host via JSON-RPC notifications. Views can emit structured log messages with severity levels (debug, info, warn, error) and arbitrary event data. The host collects these messages and can display them in a debug console, forward them to a logging service, or use them for monitoring. Messages are sent as one-way notifications (no response expected), reducing latency compared to request-response patterns. The SDK provides logging utilities that format messages consistently.","intents":["I want to send debug logs from my UI to the host for troubleshooting","I need to emit events from my UI so the host can monitor or log them","I want to track user interactions and errors in my UI without blocking the UI thread"],"best_for":["Developers building Views that need to emit diagnostic information","Teams building monitoring and observability into MCP Apps","Applications with complex Views that benefit from detailed logging"],"limitations":["Logging is one-way; Views cannot receive acknowledgment that messages were received","No built-in log aggregation or filtering; hosts must implement their own log management","High-frequency logging may overwhelm the host or consume bandwidth","Log messages are not persisted by default; hosts must implement persistence if needed"],"requires":["Host that implements SEP-1865 specification for log message handling","View code that calls logging APIs","@modelcontextprotocol/ext-apps SDK with logging utilities"],"input_types":["Log message (string)","Severity level (debug, info, warn, error)","Event data (optional, any JSON-serializable object)"],"output_types":["JSON-RPC notification messages sent to host","Formatted log entries in host debug console"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_11","uri":"capability://tool.use.integration.server.sdk.helpers.for.ui.resource.registration.and.tool.metadata","name":"server sdk helpers for ui resource registration and tool metadata","description":"Provides server-side helper functions (JavaScript/TypeScript and Python) for registering UI resources, declaring tool-UI linkage, and managing tool metadata. Helpers simplify the process of adding ui:// resources to the MCP server's resource list and linking them to tools via _meta.ui.resourceUri. The SDK validates resource declarations against the SEP-1865 specification and provides TypeScript types for tool metadata. Helpers support both inline HTML (as strings) and file-based resources.","intents":["I want to easily add UI resources to my MCP server without manually constructing resource objects","I need to link tools to UI resources with proper TypeScript type checking","I want to validate my UI resource declarations against the SEP-1865 specification"],"best_for":["MCP server developers building interactive tools","Teams using TypeScript who want type-safe tool metadata","Developers migrating from custom UI patterns to MCP Apps"],"limitations":["Helpers are SDK-specific; servers not using the SDK must manually construct resource objects","No built-in UI validation; servers must ensure HTML resources are valid and secure","Helpers do not generate UI code; developers must write HTML/CSS/JavaScript themselves","File-based resources require the server to have file system access"],"requires":["MCP server implementation (JavaScript/TypeScript or Python)","@modelcontextprotocol/ext-apps SDK installed","HTML/CSS/JavaScript UI code"],"input_types":["Tool schema with _meta field","HTML content (string or file path)","Display mode enum (optional)"],"output_types":["Registered UI resource in MCP resource list","Tool metadata with UI linkage","Validation errors if declaration is invalid"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_12","uri":"capability://automation.workflow.protocol.specification.and.message.schema.validation","name":"protocol specification and message schema validation","description":"Defines the complete MCP Apps Extension protocol (SEP-1865) with detailed message schemas, initialization handshake, tool lifecycle, and error handling. The specification is published as a formal document (specification/2026-01-26/apps.mdx) and includes JSON Schema definitions for all message types. The SDK generates TypeScript types and validation code from these schemas, enabling compile-time and runtime validation of messages. The specification covers three-party architecture, security model, display modes, and capability negotiation.","intents":["I need to understand the complete MCP Apps protocol to implement a custom host or View","I want to validate messages against the official specification to catch protocol errors","I need to implement a new MCP Apps feature and want to ensure it's compatible with the specification"],"best_for":["MCP host developers implementing SEP-1865 support","Developers building custom MCP Apps implementations","Teams implementing protocol extensions or variants"],"limitations":["Specification is formal and detailed; it may be difficult for beginners to understand","Schema validation is strict; non-compliant implementations will fail validation","Specification is versioned; older implementations may not support newer features","No automatic migration tools for protocol version upgrades"],"requires":["Understanding of JSON-RPC 2.0 protocol","Familiarity with JSON Schema","Access to the specification document (specification/2026-01-26/apps.mdx)"],"input_types":["JSON-RPC 2.0 messages","Tool schemas","Host context objects"],"output_types":["Validation results (pass/fail with error details)","TypeScript type definitions","JSON Schema documents"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_13","uri":"capability://automation.workflow.example.gallery.and.scaffolding.tools.for.rapid.prototyping","name":"example gallery and scaffolding tools for rapid prototyping","description":"Provides production-ready example servers demonstrating real-world MCP Apps use cases (map viewer, PDF viewer, system monitor, data explorer, etc.) and AI agent skills for scaffolding new Views and servers. Examples include both basic framework examples (minimal setup) and domain-specific examples (complex interactions). The repository includes build configuration (Vite), test infrastructure, and development tools for building and testing MCP Apps locally. Agent skills enable developers to generate boilerplate code for new Views and servers.","intents":["I want to see working examples of MCP Apps before building my own","I need a starting point for building a new View or server with proper structure","I want to understand best practices for MCP Apps development"],"best_for":["Developers new to MCP Apps who want to learn by example","Teams rapidly prototyping new Views or servers","Developers building domain-specific MCP Apps (maps, PDFs, data analysis)"],"limitations":["Examples are illustrative; they may not cover all edge cases or production requirements","Agent skills are AI-generated; they may require manual refinement","Examples use specific frameworks (React, Vite); developers using other frameworks must adapt","Examples may become outdated as the specification evolves"],"requires":["Node.js 18+ for running examples","npm or yarn for dependency management","Basic understanding of MCP Apps concepts"],"input_types":["Example name or domain (map, PDF, etc.)","Scaffolding parameters (View name, server type)"],"output_types":["Working example server and View code","Generated boilerplate for new projects","Build configuration and test setup"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_2","uri":"capability://tool.use.integration.app.class.lifecycle.management.with.server.tool.invocation","name":"app class lifecycle management with server tool invocation","description":"Provides the App class (View-side SDK) that manages the iframe lifecycle, initializes communication with the host via postMessage, and exposes methods to call server tools with typed parameters and receive results. The App class handles initialization handshake (exchanging protocol versions and capabilities), maintains a request-response mapping for async tool calls, and provides hooks for lifecycle events (onReady, onClose). Tool calls are wrapped in JSON-RPC requests with automatic ID generation and timeout handling, with results returned as Promise-based responses.","intents":["I need to initialize my UI code and establish communication with the MCP host when the iframe loads","I want to call server tools from my UI and handle the async results with proper error handling","I need to know when the host is ready and when the iframe is being closed so I can clean up resources"],"best_for":["Frontend developers building interactive UIs that need to invoke server-side tools","React developers using the provided useApp hook for declarative tool calling","Vanilla JavaScript developers building lightweight UI components without framework dependencies"],"limitations":["Tool calls are async and require Promise handling; no synchronous tool invocation","Request timeout is fixed (typically 30s); no per-call timeout customization in base API","App class is View-side only; it cannot directly access host state or other Views","No built-in retry logic for failed tool calls — applications must implement their own retry strategies"],"requires":["TypeScript 4.5+ or JavaScript ES2020+ for async/await support","Browser environment with postMessage support","MCP host with AppBridge integration to handle App initialization messages","@modelcontextprotocol/ext-apps SDK imported in View code"],"input_types":["Tool name (string)","Tool parameters (object matching tool schema)","Lifecycle event handlers (callbacks)"],"output_types":["Tool execution result (JSON-RPC response)","Error objects with code and message","Lifecycle event notifications (ready, close)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_3","uri":"capability://tool.use.integration.react.integration.with.useapp.and.useappbridge.hooks","name":"react integration with useapp and useappbridge hooks","description":"Provides React hooks (useApp, useAppBridge) that wrap the App and AppBridge classes, enabling declarative tool calling and host integration within React components. The useApp hook returns the initialized App instance with automatic cleanup on unmount, while useAppBridge provides host-side access to the bridge for managing Views and forwarding requests. Hooks handle the initialization timing, ensuring the App is ready before components attempt tool calls, and provide TypeScript support for tool schemas and parameters.","intents":["I want to use React hooks to call server tools from my UI components without managing App initialization manually","I need type-safe tool calling in React with proper TypeScript support for tool parameters","I want to build a host application that manages multiple Views and forwards requests to servers"],"best_for":["React developers building interactive UI components for MCP Apps","Teams using TypeScript who want full type safety for tool schemas","Host developers building React-based applications that embed multiple MCP Views"],"limitations":["React 16.8+ required for hooks support; no class component API provided","Hooks must be called at the top level of components; cannot be used conditionally","useApp hook throws an error if called outside an MCP App context (no graceful fallback)","No built-in state management for tool results; applications must use useState or external state libraries"],"requires":["React 16.8+ with hooks support","TypeScript 4.5+ for type-safe tool schema inference","@modelcontextprotocol/ext-apps SDK with React exports","App or AppBridge context provider wrapping the component tree"],"input_types":["Tool name and parameters (typed from tool schema)","Lifecycle callbacks (optional)"],"output_types":["App or AppBridge instance","Tool execution results","Error objects"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_4","uri":"capability://tool.use.integration.appbridge.host.side.request.forwarding.and.capability.negotiation","name":"appbridge host-side request forwarding and capability negotiation","description":"Provides the AppBridge class (Host-side SDK) that manages iframe lifecycle, forwards tool requests from Views to MCP servers, and handles capability negotiation during initialization. AppBridge intercepts JSON-RPC requests from Views, validates them against declared tool schemas, forwards them to the appropriate MCP server, and returns results back to the View. It also manages host context (styling, display mode) and sends notifications to Views. Capability negotiation ensures both View and Host agree on protocol version and supported features before tool execution begins.","intents":["I need to embed MCP App Views in my host application and route their tool requests to the correct servers","I want to negotiate capabilities with Views to ensure compatibility before they attempt tool calls","I need to send notifications and host context (styling, display mode) to Views dynamically"],"best_for":["Host application developers (Claude, ChatGPT, custom MCP clients) integrating MCP Apps","Teams building conversational AI products that need to manage multiple embedded Views","Developers building MCP client applications with rich UI support"],"limitations":["AppBridge requires an active MCP server connection; it cannot execute tools locally","Request forwarding adds latency (typically 50-200ms) compared to direct server calls","No built-in load balancing or failover for multiple servers; applications must implement their own routing","Capability negotiation is one-time at initialization; dynamic capability changes are not supported"],"requires":["TypeScript 4.5+ or JavaScript ES2020+ for AppBridge implementation","Active MCP server connection with tool definitions","Browser environment with postMessage support","@modelcontextprotocol/ext-apps SDK with AppBridge exports"],"input_types":["JSON-RPC requests from Views (tool calls)","MCP server tool schemas","Host context (styling, display mode)","Capability declarations from both View and Host"],"output_types":["JSON-RPC responses (tool results or errors)","Notifications sent to Views","Capability negotiation results"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_5","uri":"capability://tool.use.integration.postmessagetransport.abstraction.for.json.rpc.2.0.messaging","name":"postmessagetransport abstraction for json-rpc 2.0 messaging","description":"Provides a PostMessageTransport class that abstracts the low-level postMessage API into a JSON-RPC 2.0 transport layer. It handles message serialization/deserialization, request-response correlation via message IDs, error handling, and timeout management. The transport validates incoming messages against the JSON-RPC 2.0 spec, maintains a pending request map, and routes responses to the correct handlers. It supports both request-response patterns (for tool calls) and one-way notifications (for logs, events).","intents":["I need a reliable transport layer for JSON-RPC 2.0 communication over postMessage without implementing it from scratch","I want automatic request-response correlation and timeout handling for async RPC calls","I need to validate messages against the JSON-RPC 2.0 specification to catch protocol errors early"],"best_for":["Developers building custom MCP Apps or hosts who need low-level transport control","Teams implementing protocol extensions that require custom message handling","Developers debugging communication issues between Views and Hosts"],"limitations":["PostMessageTransport is a low-level primitive; developers must handle tool schema validation and request routing themselves","No built-in message compression; large payloads are sent uncompressed, increasing bandwidth usage","Timeout is fixed at initialization; no per-request timeout customization","No built-in retry logic for failed messages; applications must implement their own retry strategies"],"requires":["TypeScript 4.5+ or JavaScript ES2020+ for async/await support","Browser environment with postMessage support","@modelcontextprotocol/ext-apps SDK with PostMessageTransport export"],"input_types":["JSON-RPC 2.0 request/response messages","Window or Worker objects for postMessage targets","Message handlers (callbacks)"],"output_types":["Serialized JSON-RPC 2.0 messages sent via postMessage","Deserialized message objects with validation"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_6","uri":"capability://automation.workflow.host.context.and.styling.propagation.to.views","name":"host context and styling propagation to views","description":"Enables hosts to send context information (theme, display mode, viewport size) and CSS styling to Views via JSON-RPC messages. The host can declare supported display modes (inline, modal, sidebar) and the View can query or subscribe to host context changes. The SDK provides styling utilities that generate CSS variables and theme classes based on host context, allowing Views to adapt their appearance to the host's design system. Context is propagated during initialization and can be updated dynamically.","intents":["I want my UI to automatically adapt to the host's theme (light/dark mode) without hardcoding colors","I need to know the available display modes so I can adjust my layout accordingly","I want to receive viewport size changes from the host so my UI can be responsive"],"best_for":["UI developers building Views that need to match the host's design system","Teams building multi-host applications (Claude, ChatGPT, custom clients) with consistent styling","Developers building responsive UIs that adapt to different display modes"],"limitations":["Host context is read-only from the View's perspective; Views cannot change host styling","CSS variables are host-dependent; not all hosts may provide the same set of variables","Display mode is advisory; the host may ignore the View's preferred display mode","Context updates are not real-time; there may be a delay between host changes and View updates"],"requires":["Host that implements SEP-1865 specification for context propagation","CSS support in the View for CSS variables (custom properties)","@modelcontextprotocol/ext-apps SDK with styling utilities"],"input_types":["Host context object (theme, display mode, viewport size)","CSS variable declarations","Theme enum values"],"output_types":["CSS variables applied to View elements","Theme class names (e.g., 'dark-mode')","Display mode information"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_7","uri":"capability://automation.workflow.progressive.rendering.and.streaming.responses.from.server.tools","name":"progressive rendering and streaming responses from server tools","description":"Supports progressive rendering where server tools can send partial results to Views via streaming or chunked responses. The View can display intermediate results as they arrive, improving perceived performance for long-running operations. The protocol supports both complete responses (single JSON-RPC response) and streaming responses (multiple messages with a completion marker). The SDK provides utilities for handling streaming results and updating the UI incrementally.","intents":["I want to show partial results to the user while a long-running tool is still executing","I need to stream large data sets from the server without waiting for the entire response","I want to provide real-time updates to the UI as the server processes data"],"best_for":["Developers building data exploration tools that process large datasets","Teams building real-time dashboards or monitoring UIs","Applications with long-running operations (data analysis, report generation) that benefit from progressive feedback"],"limitations":["Streaming requires server-side support; not all MCP servers implement streaming responses","Progressive rendering adds complexity to View code; developers must handle partial results and completion markers","No built-in buffering or batching of streamed messages; high-frequency updates may overwhelm the UI","Streaming responses are not idempotent; retrying a streaming request may produce different results"],"requires":["MCP server that implements streaming response support","View code that handles partial results and streaming completion markers","@modelcontextprotocol/ext-apps SDK with streaming utilities"],"input_types":["Tool name and parameters","Streaming configuration (chunk size, timeout)"],"output_types":["Partial result objects (intermediate data)","Completion marker indicating end of stream","Error objects if streaming fails"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_8","uri":"capability://memory.knowledge.state.persistence.and.local.storage.management.in.views","name":"state persistence and local storage management in views","description":"Provides patterns and utilities for Views to persist state locally (in browser storage) or request persistence from the server. Views can store UI state (form inputs, scroll position, selected items) locally to survive iframe reloads, or request the server to store application state. The SDK provides helper functions for serializing/deserializing state and managing storage quotas. State can be scoped to the View instance or shared across multiple Views of the same type.","intents":["I want my UI to remember user inputs and scroll position if the iframe is reloaded","I need to sync state between multiple Views of the same type","I want to persist application state on the server so it survives browser restarts"],"best_for":["Developers building stateful UIs that benefit from persistence across reloads","Teams building multi-View applications that need to share state","Applications with complex forms or exploratory UIs where users expect state to be preserved"],"limitations":["Browser storage is limited (typically 5-10MB per origin); large state objects may exceed quota","Local storage is not encrypted; sensitive data should not be stored locally","State persistence is not automatic; developers must explicitly save and restore state","Server-side persistence requires additional server implementation; not all MCP servers support it"],"requires":["Browser with localStorage or sessionStorage support","View code that explicitly saves and restores state","Optional: MCP server with state persistence endpoints"],"input_types":["State object (any JSON-serializable data)","Storage key (string)","Storage scope (local, session, or server)"],"output_types":["Serialized state stored in browser or server","Restored state object on View initialization"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-modelcontextprotocol-ext-apps__cap_9","uri":"capability://tool.use.integration.tool.visibility.control.and.conditional.ui.rendering","name":"tool visibility control and conditional ui rendering","description":"Enables MCP servers to control which tools are visible to which Views via tool metadata and visibility rules. Tools can be marked as hidden, visible only in certain display modes, or visible only to specific View types. The host respects these visibility rules when forwarding requests and rendering UIs. Views can query the host for available tools and their visibility status, allowing them to conditionally render UI elements based on tool availability. This enables servers to provide different tool sets to different Views without duplicating tool definitions.","intents":["I want to hide certain tools from specific Views based on context or permissions","I need to provide different tool sets to different display modes (inline vs modal)","I want Views to know which tools are available so they can conditionally render UI elements"],"best_for":["Developers building multi-tenant or role-based MCP applications","Teams building Views that adapt to available tools","Applications with context-dependent tool availability"],"limitations":["Visibility rules are static; they cannot change dynamically based on runtime conditions","No fine-grained permission system; visibility is binary (visible or hidden)","Views must implement their own logic to handle missing tools gracefully","Visibility rules are enforced by the host; malicious Views could attempt to call hidden tools"],"requires":["MCP server that declares tool visibility metadata","Host that respects visibility rules when forwarding requests","View code that queries available tools and adapts accordingly"],"input_types":["Tool metadata with visibility rules","Display mode enum","View type identifier"],"output_types":["Filtered tool list based on visibility rules","Tool availability status"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":49,"verified":false,"data_access_risk":"high","permissions":["TypeScript 4.5+ or JavaScript ES2020+ for View/Host implementation","Browser with postMessage support (all modern browsers)","MCP server implementing SEP-1865 specification for resource declaration","Host application with AppBridge integration to manage iframe lifecycle and message routing","MCP server implementation (JavaScript/TypeScript or Python with MCP SDK)","HTML/CSS/JavaScript UI code as a string or file resource","Tool definition with _meta.ui.resourceUri field populated","Host that implements SEP-1865 specification for resource fetching","Host that implements SEP-1865 specification for log message handling","View code that calls logging APIs"],"failure_modes":["No direct DOM access from View to Host — all communication must go through JSON-RPC message passing, adding latency per request","Iframe sandbox restrictions prevent certain browser APIs (localStorage, cookies, cross-origin requests) unless explicitly granted via sandbox attributes","Message size is limited by postMessage implementation (~1MB per message in most browsers); large data transfers require chunking or streaming patterns","No built-in persistence layer — Views must implement their own state management or request persistence from the server","UI resources must be valid HTML/CSS/JavaScript; no server-side templating or dynamic generation at declaration time","Tool-UI linkage is static — a tool can only link to one UI resource; multiple UIs require multiple tools","Display mode hints are advisory; hosts may ignore them based on their own layout constraints","No built-in mechanism for UI versioning conflicts — servers must manage version compatibility with older hosts","Logging is one-way; Views cannot receive acknowledgment that messages were received","No built-in log aggregation or filtering; hosts must implement their own log management","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.5090188444578634,"quality":0.5,"ecosystem":0.5800000000000001,"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-04-30T15:42:48Z"},"community":{"stars":2149,"forks":266,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-modelcontextprotocol-ext-apps","compare_url":"https://unfragile.ai/compare?artifact=mcp-modelcontextprotocol-ext-apps"}},"signature":"1YLJW1I59JY0PQxkccAuQWDSjq7AxacPtCnScuwIYvTW8z+Wmir/CaNIQJEycqesZF8xhMlvCc3/zLPCLl/yAw==","signedAt":"2026-06-21T04:01:31.866Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-modelcontextprotocol-ext-apps","artifact":"https://unfragile.ai/mcp-modelcontextprotocol-ext-apps","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-modelcontextprotocol-ext-apps","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"}}