Merge branch 'main' into groups

Author: cliffhall

.github/workflows/render-seps.yml

@@ -33,10 +33,18 @@ jobs:
 
       - run: npm ci
 
+      # On PR, verify rendered docs are up to date (must run BEFORE generate)
+      - name: Verify SEPs are up to date
+        if: github.event_name == 'pull_request'
+        run: npm run check:seps
+
+      # On push to main, generate and commit any changes
       - name: Render SEPs
+        if: github.event_name == 'push' || github.event_name == 'workflow_dispatch'
         run: npm run generate:seps
 
       - name: Check for changes
+        if: github.event_name == 'push' || github.event_name == 'workflow_dispatch'
         id: changes
         run: |
           if [[ -n "$(git status --porcelain docs/community/seps/ docs/snippets/badge.mdx docs/docs.json)" ]]; then
@@ -45,7 +53,6 @@ jobs:
             echo "has_changes=false" >> $GITHUB_OUTPUT
           fi
 
-      # On push to main, commit any changes
       - name: Commit changes
         if: github.event_name == 'push' && github.ref == 'refs/heads/main' && steps.changes.outputs.has_changes == 'true'
         run: |
@@ -54,8 +61,3 @@ jobs:
           git add docs/community/seps/ docs/snippets/badge.mdx docs/docs.json
           git commit -m "docs: auto-render SEPs documentation"
           git push
-
-      # On PR, verify docs are up to date
-      - name: Verify SEPs are up to date
-        if: github.event_name == 'pull_request'
-        run: npm run check:seps

.prettierignore

@@ -1,2 +1,3 @@
 docs/specification/*/schema.md
 docs/specification/*/schema.mdx
+docs/registry/

blog/content/posts/2026-01-26-mcp-apps.md

@@ -0,0 +1,264 @@
+---
+date: "2026-01-26T00:00:00+00:00"
+publishDate: "2026-01-26T00:00:00+00:00"
+title: "MCP Apps - Bringing UI Capabilities To MCP Clients"
+author: "MCP Core Maintainers"
+tags: ["mcp", "extensions", "apps"]
+ShowToc: true
+---
+
+Today, we're announcing that **MCP Apps are now live as an official MCP extension**.
+Tools can now return interactive UI components that render directly in the
+conversation: dashboards, forms, visualizations, multi-step workflows, and more.
+This is the first official MCP extension, and it's ready for production.
+
+{{< youtube bluAmTHoEow >}}
+
+We proposed MCP Apps
+[last November](https://blog.modelcontextprotocol.io/posts/2025-11-21-mcp-apps/), building on
+the amazing work of [MCP-UI](https://mcpui.dev) and the
+[OpenAI Apps SDK](https://developers.openai.com/apps-sdk/). We were excited to partner with
+both OpenAI and MCP-UI to create a shared open standard for providing affordances for
+developers to include UI components in their MCP clients.
+
+Since then, the spec has been refined, the SDK has matured, and clients like ChatGPT, Claude,
+Goose and Visual Studio Code have shipped support for this capability, with more clients
+coming soon.
+
+{{< button text="Get Started with MCP Apps" url="https://modelcontextprotocol.github.io/ext-apps/api/documents/Quickstart.html" >}}
+
+## **What Are MCP Apps?**
+
+MCP Apps let tools return rich, interactive interfaces instead of plain text. When a tool
+declares a UI resource, the host renders it in a sandboxed iframe, and users interact with
+it directly in the conversation.
+
+![Color picker MCP App working in Claude.ai](/posts/images/mcp-apps/claude-colorpicker-apps.gif)
+
+Here are a few scenarios where MCP Apps shine:
+
+- **Data exploration**: A sales analytics tool returns an interactive dashboard. Users filter
+  by region, drill down into specific accounts, and export reports without leaving the
+  conversation.
+- **Configuration wizards**: A deployment tool presents a form with dependent fields.
+  Selecting "production" reveals additional security options; selecting "staging" shows
+  different defaults.
+- **Document review**: A contract analysis tool displays the PDF inline with highlighted
+  clauses. Users click to approve or flag sections, and the model sees their decisions in
+  real time.
+- **Real-time monitoring**: A server health tool shows live metrics that update as systems
+  change. No need to re-run the tool to see current status.
+
+These interactions would be less smooth as text exchanges, whereas MCP Apps make them
+natural - it's like using any other UI-based web app.
+
+## **How It Works**
+
+The architecture of MCP Apps relies on two key MCP primitives:
+
+1. **Tools with UI metadata**: Tools include a `_meta.ui.resourceUri` field pointing to a UI
+   resource
+2. **UI Resources**: Server-side resources served via the `ui://` scheme containing bundled
+   HTML/JavaScript
+
+```javascript
+// Tool with UI metadata
+{
+  name: "visualize_data",
+  description: "Visualize data as an interactive chart",
+  inputSchema: { /* ... */ },
+  _meta: {
+    ui: {
+      resourceUri: "ui://charts/interactive"
+    }
+  }
+}
+```
+
+The host fetches the resource, renders it in a sandboxed iframe, and enables bidirectional
+communication via JSON-RPC over `postMessage`.
+
+## **Why MCP Apps?**
+
+MCP is great for connecting models to data and giving them the ability to take actions. But
+there's still a context gap between what tools can do and what users can see.
+
+Consider a tool that queries your database. It returns rows of data, maybe hundreds of them.
+The model can summarize this data, but users often want to explore: sort by a column, filter
+to a date range, or click into a specific record. With text responses, every interaction
+requires another prompt. "Show me just the ones from last week." "Sort by revenue." "What's
+the detail on row 47?" It works, but it's slow.
+
+MCP Apps closes this gap. The model stays in the loop, seeing what users do and responding
+accordingly, but the UI handles what text can't: live updates, native media viewers,
+persistent states, and direct manipulation. Combined, they provide the model and user with
+all the context they need in one familiar interface.
+
+## **The App API**
+
+To build new MCP Apps, developers can use the
+[`@modelcontextprotocol/ext-apps`](https://www.npmjs.com/package/@modelcontextprotocol/ext-apps)
+package, which provides an `App` class for UI-to-host communication:
+
+```javascript
+import { App } from "@modelcontextprotocol/ext-apps";
+
+const app = new App();
+await app.connect();
+
+// Receive tool results from the host
+app.ontoolresult = (result) => {
+  renderChart(result.data);
+};
+
+// Call server tools from the UI
+const response = await app.callServerTool({
+  name: "fetch_details",
+  arguments: { id: "123" },
+});
+
+// Update model context
+await app.updateModelContext({
+  content: [{ type: "text", text: "User selected option B" }],
+});
+```
+
+Because apps run inside the client, they can do things a plain iframe can't. They can log
+events for debugging, open links in the user's browser, send follow-up messages to drive the
+conversation forward, or quietly update the model's context for later. All of this happens
+over standard `postMessage`, so you're not locked into any framework.
+
+## **Security Model**
+
+Running UI from MCP servers means running code you didn't write within your MCP host. MCP
+Apps handles this through multiple layers:
+
+- **Iframe sandboxing**: All UI content runs in sandboxed iframes with restricted permissions
+- **Pre-declared templates**: Hosts can review HTML content before rendering
+- **Auditable messages**: All UI-to-host communication goes through loggable JSON-RPC
+- **User consent**: Hosts can require explicit approval for UI-initiated tool calls
+
+If something looks suspicious, hosts can block it before it ever renders. Of course, users
+should continue to proactively and thoroughly vet MCP servers before connecting them.
+
+## **The Future of Agentic UI Frameworks**
+
+[MCP-UI](https://mcpui.dev/) and [OpenAI Apps SDK](https://developers.openai.com/apps-sdk/)
+pioneered the patterns that MCP Apps now standardizes. The projects proved that UI resources
+can and do fit naturally within the MCP ecosystem, with enterprises of all sizes adopting
+both the OpenAI and MCP-UI SDKs for production applications.
+
+MCP-UI isn't going anywhere. The SDKs support MCP Apps patterns, with the Client SDK as the
+recommended framework for Hosts looking to adopt MCP Apps. The community continues to
+contribute extensively to the specification. If you're already using MCP-UI, keep using it.
+Migration to the official extension is straightforward when you're ready.
+
+## **Client Support**
+
+MCP Apps are supported in:
+
+- **Claude** - available today both on web and desktop experiences
+- **Goose** - [available today](https://block.github.io/goose/docs/tutorials/building-mcp-apps/)
+- **Visual Studio Code** - available in
+  [Visual Studio Code Insiders](https://code.visualstudio.com/insiders)
+- **ChatGPT** - starting this week
+
+For the first time, an MCP tool developer can ship an interactive experience that works
+across a broad range of widely-adopted clients without writing a single line of
+client-specific code.
+
+> "_I am excited about the possibilities that MCP Apps opens up. Having seen a glimpse of what is possible, I cannot wait to see what the community will build._"
+>
+> - **David Soria Parra**, Co-Creator of MCP and Member of Technical Staff, [Anthropic](https://www.anthropic.com/)
+
+> “_MCP Apps builds upon the foundations of MCP-UI and the ChatGPT Apps SDK to give people a rich visually interactive experience. We're proud to support this new open standard and look forward to seeing what developers build with it as we grow the selection of apps available in ChatGPT._”
+>
+> - **Nick Cooper**, Member of Technical Staff, [OpenAI](https://openai.com/)
+
+> “_MCP Apps extends the Model Context Protocol in a way that puts humans at the center. The industry has embedded assistants into individual apps, creating fragmented, siloed experiences. MCP inverts this by making apps pluggable components within agents. MCP Apps extends this further by bringing user interfaces into the agent experience itself._
+>
+> _goose, the reference implementation for MCP, supports MCP Apps. Developers can now build interactive experiences that render directly in conversation: games, calendars, maps, checkout flows. At Block, we believe the future centers on users navigating through one trusted agent rather than context-switching between fragmented experiences, and MCP Apps supports that vision. We're excited to support this standard and see where developers take it._”
+>
+> - **Andrew Harvard**, Design Engineer, Agentic UX, [Block](https://block.xyz/)
+
+> _“As MCP evolves from ‘tools’ into a real platform for agentic work, VS Code has been treating the protocol like a contract: implement the full spec, track the latest transports and capabilities, and make sure server authors can rely on what they build actually behaving the same way for real developers. With MCP Apps, that contract finally includes the missing human step: when the workflow needs a decision, a selection, or exploration, the client can give you the right interaction without turning the conversation into a choose-your-own-adventure prompt.”_
+>
+> - **Harald Kirschner**, Principal Product Manager, VS Code, [Microsoft](https://www.microsoft.com/en-us)
+
+> “_The MCP Apps extension addresses a gap we have experienced first-hand: text and structured data only gets you so far when developers want rich, interactive tooling. The ability to render dynamic UIs directly from MCP servers, with security built in from day one, is exactly what we need to build better agentic experiences. JetBrains is excited to explore bringing this extension to our IDEs and continue working with the MCP Community._”
+>
+> - **Denis Shiryaev**, Head of AI DevTools Ecosystem, [JetBrains](https://www.jetbrains.com/)
+
+> _“MCP Apps address a real gap between what agentic tools can provide and how users naturally want to interact with them. The ability to render dynamic interfaces directly in conversation makes it easier to leverage MCP server capabilities in practical ways. We're excited to see this extension deliver richer interactions for users while enabling MCP server developers to craft experiences tailored to what they're building. We’re excited to see how we can bring these capabilities to Kiro and the use cases it’ll unlock for our users.“_
+>
+> - **Clare Liguori**, Senior Principal Engineer, [AWS](https://aws.amazon.com/)
+
+> "The Antigravity team is excited to see the continued expansion of the MCP ecosystem, and will explore how MCP apps could enable new, magical experiences within Antigravity."
+>
+> - **Anshul Ramachandran**, Product Lead, Antigravity, [Google DeepMind](https://deepmind.google/)
+
+This is just the starting lineup, and adding support to a new client is as easy as following
+the [implementation guide](https://modelcontextprotocol.io/docs/extensions/apps).
+
+## **Get Started**
+
+The [ext-apps repository](https://github.com/modelcontextprotocol/ext-apps) includes the SDK
+and working examples:
+[`threejs-server`](https://github.com/modelcontextprotocol/ext-apps/tree/main/examples/threejs-server)
+for 3D visualization,
+[`map-server`](https://github.com/modelcontextprotocol/ext-apps/tree/main/examples/map-server)
+for interactive maps,
+[`pdf-server`](https://github.com/modelcontextprotocol/ext-apps/tree/main/examples/pdf-server)
+for document viewing,
+[`system-monitor-server`](https://github.com/modelcontextprotocol/ext-apps/tree/main/examples/system-monitor-server)
+for real-time dashboards,
+[`sheet-music-server`](https://github.com/modelcontextprotocol/ext-apps/tree/main/examples/sheet-music-server)
+for music notation, and
+[many more](https://github.com/modelcontextprotocol/ext-apps/tree/main/examples).
+
+Pick one close to what you're building and start from there!
+
+![Color picker MCP App working in Visual Studio Code](/posts/images/mcp-apps/vscode-colorpicker-apps.gif)
+
+### **Resources**
+
+- **Documentation**: [MCP Apps Guide](https://modelcontextprotocol.io/docs/extensions/apps)
+- **Quickstart**: [Getting Started with MCP Apps](https://modelcontextprotocol.github.io/ext-apps/api/documents/Quickstart.html)
+- **SDK**: [`@modelcontextprotocol/ext-apps`](https://www.npmjs.com/package/@modelcontextprotocol/ext-apps)
+- **Examples**: [ext-apps repository](https://github.com/modelcontextprotocol/ext-apps)
+
+### [**Claude.ai**](http://Claude.ai) **Feedback**
+
+If you're building MCP Apps for [Claude.ai](http://Claude.ai) and encounter issues with our
+implementation, please report them at
+[github.com/anthropics/claude-ai-mcp](https://github.com/anthropics/claude-ai-mcp). This
+helps us improve the experience for everyone.
+
+### **ChatGPT Apps SDK Feedback**
+
+If you're building apps with the ChatGPT Apps SDK and run into issues or have questions,
+please post in the
+[ChatGPT Apps category](https://community.openai.com/c/chatgpt-apps-sdk/42) on the OpenAI
+Community forum. This is where app developers, community moderators, and the OpenAI team
+actively engage to discuss builds, troubleshoot problems, and improve the overall developer
+experience.
+
+## **Acknowledgements**
+
+MCP Apps is the result of collaboration across multiple teams and communities.
+
+**Ido Salomon** and **Liad Yosef** created MCP-UI and moderated the `#ui-wg` channel,
+incubating many of the patterns that MCP Apps now standardizes. Their work proved that
+interactive UIs belong in MCP.
+
+**Nick Cooper** at OpenAI helped deliver the OpenAI Apps SDK, enabling everyone to go beyond
+text in their interactions with Large Language Models.
+
+**Sean Strong**, **Olivier Chafik**, **Anton Pidkuiko**, and **Jerome Swannack** from
+Anthropic helped steer the initiative from proposal to production.
+
+The **UI Community Working Group** provided feedback through countless discussions, reviewed
+drafts, tested early implementations, and pushed for the right trade-offs between flexibility
+and security.
+
+Thank you to everyone who contributed. Now go build something.

blog/layouts/shortcodes/button.html

@@ -0,0 +1,49 @@
+{{- $text := .Get "text" | default "Learn More" -}}
+{{- $url := .Get "url" | default "#" -}}
+{{- $target := .Get "target" | default "_blank" -}}
+
+<a href="{{ $url }}" target="{{ $target }}" rel="noopener noreferrer" class="mcp-button">
+  {{ $text }} <span class="mcp-button-arrow">→</span>
+</a>
+
+<style>
+.mcp-button {
+  display: inline-block;
+  padding: 8px 16px;
+  font-size: 14px;
+  font-weight: 500;
+  text-decoration: none;
+  border-radius: 4px;
+  transition: all 0.2s ease;
+  margin: 12px 0;
+  background-color: #1a1a1a;
+  color: #ffffff;
+  border: 1px solid #333;
+}
+
+.mcp-button:hover {
+  background-color: #333;
+  color: #ffffff;
+}
+
+.mcp-button-arrow {
+  margin-left: 6px;
+  transition: transform 0.2s ease;
+  display: inline-block;
+}
+
+.mcp-button:hover .mcp-button-arrow {
+  transform: translateX(3px);
+}
+
+.dark .mcp-button {
+  background-color: #ffffff;
+  color: #1a1a1a;
+  border: 1px solid #e5e5e5;
+}
+
+.dark .mcp-button:hover {
+  background-color: #f0f0f0;
+  color: #1a1a1a;
+}
+</style>

blog/layouts/shortcodes/youtube.html

@@ -0,0 +1,30 @@
+{{- $id := .Get "id" | default (.Get 0) -}}
+{{- $title := .Get "title" | default "YouTube video" -}}
+
+<div class="youtube-container">
+  <iframe
+    src="https://www.youtube.com/embed/{{ $id }}"
+    title="{{ $title }}"
+    frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+    allowfullscreen>
+  </iframe>
+</div>
+
+<style>
+.youtube-container {
+  position: relative;
+  width: 100%;
+  padding-bottom: 56.25%; /* 16:9 aspect ratio */
+  margin: 24px 0;
+}
+
+.youtube-container iframe {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  border-radius: 8px;
+}
+</style>