Skip to main content
MCP Apps let a tool show an interactive view alongside its result: a weather forecast, a diagram editor, or a chart you can filter. The server supplies the tool and an HTML resource; the client renders the view. Several tools on one server can each declare a view, or share the same one. An MCP App is different from an Atlan app installed from Store. Adding a server does not create a view for an ordinary tool: the server must implement the MCP Apps extension.

Before you begin

  • Register and connect an MCP server that declares App tools.
  • Have permission to run that server’s tools. Connect your own provider account if it uses per-person OAuth.
  • Use Studio’s Playground or a client that supports MCP Apps rendering. Supporting MCP tool calls alone does not imply UI support.
Availability depends on your environment’s MCP Apps configuration and the operations the App requires. See Supported features and limits.

Try an App in Studio

1

Find a tool with a view

Open the server in MCP Studio and select Open playground. Choose the server, then use the MCP Apps filter to find tools with views. A tool’s Interactive UI badge means discovery found a UI declaration; it does not guarantee that the view will load.
2

Run the tool

Select a tool, enter its parameters using Fields or JSON, and select Run tool. Review any prefilled sample values before running. The call uses your existing permissions and connected credentials. Some tools can change data.
3

Use the view

Open App preview. Interact with the view, for example by changing a filter. If it calls a tool, UI tool calls shows the callback and its outcome. Use Results and Raw JSON to inspect the original result.
4

Expand or reload

Where available, select Expand App for more space and Return inline, or press Escape, to return. Expansion keeps the same App instance. If startup fails, Reload preview loads the view again using the completed result; it does not repeat the original tool operation.
Studio loads third-party HTML in a sandbox on a separate origin. The sandbox prevents the App from reading the Studio page or its credentials. Your browser must be able to reach that sandbox; the gateway reaching the MCP server is a separate connection.

Use an App in your client

Connect your client to the usual gateway endpoint:
Sign in to the organization that contains the server. In a client with MCP Apps support, refresh its connector’s tool list or open a fresh chat after adding a server or changing access. Your organization’s client administrator may need to allow custom connectors. Ask for the server’s native App tool, for example:
Use the Weather server’s forecast App to show the next week in Bengaluru in metric units. Display its interactive view in this chat.
Use the exact tool name and schema advertised by your connection. To display the App, the client calls that App entry directly. Calling the same operation through mcp__call_tool returns data without opening its App. No separate App-execution tool or connector for each downstream server is required. The external client owns its renderer and sandbox; it does not use Studio’s sandbox. Desktop and terminal versions of the same product can have different UI capabilities. A text response or a separately generated page is not evidence that the MCP App rendered.

How this works with search mode

Ordinary tools still use search, describe, and call. Searches return five matches by default. When aggregate Apps are enabled, a UI-capable connection also receives authorized native App entry definitions in its initial tool list, so the client can associate each call with its view. UI-only helper tools stay out of model discovery. A callback from the App returns through the gateway to the same owning server. The gateway translates the native callback name, checks current access and resolves credentials again. Two servers can both name a callback refresh without their Apps calling each other’s tools.

Troubleshooting

A successful tool execution and a successful view load are separate outcomes. If the view fails, inspect the existing result before running the tool again, especially for write operations.

See also