Installation

To install this module, you need to:

Download the module and add it to your Odoo addons folder. Afterward, log on to your Odoo server and go to the Apps menu. Trigger the debug mode and update the list by clicking on the "Update Apps List" link. Now install the module by clicking on the install button.

Upgrade

To upgrade this module, you need to:

Download the module and add it to your Odoo addons folder. Restart the server and log on to your Odoo server. Select the Apps menu and upgrade the module by clicking on the upgrade button.

Configuration

The module is server-side only — once installed, the io.modelcontextprotocol/ui capability is advertised on every MCP initialize handshake and the bundled ui:// resources show up in resources/list automatically. No per-host configuration needed beyond what MuK MCP Server already requires (Bearer token + endpoint URL).

Brand Color

The inlined OWL bundle picks up the company's primary color and exposes it to apps as CSS custom properties (--o-primary, --o-primary-hover, --o-primary-soft). Override per-tenant via Settings > General Settings > MCP Server > Primary Color, or leave blank to inherit the company default.

Resource Management

Open Settings > MCP Server > Resources to inspect every registered ui:// resource. Each record carries the source module, app directory, asset-inlining flags, CSP policy, permission flags, and the comma-separated list of entrypoint tools that drive it.

Built-in Apps

The module ships with two ready-to-use ui:// resources.

View App (ui://muk_mcp_apps/view)

Renders any Odoo OWL view (list, kanban, form, pivot, graph) for an arbitrary model with custom domain, group-by, measures, chart type, and ad-hoc arch. Driven by the view_action MCP tool. Useful for giving the AI host a real, interactive Odoo view in-conversation instead of a flat JSON dump.

Dashboard App (ui://muk_mcp_apps/dashboard)

Renders a full o_spreadsheet dashboard with optional single-figure isolation and global-filter presets. Driven by the dashboard_read MCP tool. Same renderer the Odoo backend uses, running inside the host's iframe.

How It Works

When a tool returns a resource_link with structured input, the host fetches the matching ui:// resource. The server returns a single self-contained HTML document with:

• the OWL framework, view layer, and adapter services inlined as a bundle script,
• the host-bridge SDK that brokers JSON-RPC over postMessage,
• a <script> block bootstrapping window.odoo.__session_info__ so the OWL action manager mounts as if it were a real backend,
• a server-computed brand theme exposed as CSS custom properties,
• per-app CSP and permission metadata in _meta.ui per the Apps spec,
• a content hash on the resource descriptor so caching hosts can skip resources/read when nothing changed.

The iframe runs in an isolated sandbox origin. Any backend call it makes (record reads, writes, chatter, RPC) is intercepted by the boot script and routed to the web_proxy MCP tool, which replays it server-side under the authenticated MCP session and returns the response.

Playground

Open Settings > MCP Server > Playground and switch to the Resources tab to inspect every registered ui:// resource. Each entry shows:

• a live iframe rendering the app,
• an App Runner toolbar that dispatches the resource's entrypoint tool with form-driven JSON arguments and reloads the iframe with the resulting structuredContent,
• a side log capturing every JSON-RPC frame flowing through the host bridge, with Replay and Edit & Replay buttons.

No external host required — the playground is the same dispatch path the host would use, so what works here works in Claude.

Custom Apps

Ship your own ui:// resource from any Odoo addon.

Step 1 — declare the dependency in your __manifest__.py:

{
    'name': 'My MCP App',
    'depends': ['muk_mcp_apps'],
    ...
}

Step 2 — drop an index.html under your_addon/static/src/apps/<app>/.

Step 3 — register a muk_mcp_apps.ui_resource record:

<record id="ui_resource_my_app" model="muk_mcp_apps.ui_resource">
    <field name="uri">ui://your_addon/my_app</field>
    <field name="name">My App</field>
    <field name="module">your_addon</field>
    <field name="app_path">static/src/apps/my_app</field>
    <field name="inline_assets" eval="True"/>
    <field name="entrypoint_tools">my_tool</field>
</record>

Step 4 — attach the resource to your tool with the decorator's meta argument:

@mcp_tool(
    name='my_tool',
    description='...',
    input_schema={...},
    category='read',
    meta={'ui': {'resourceUri': 'ui://your_addon/my_app'}},
)
def _mcp_my_tool(self, ...):
    ...

The server takes care of inlining assets, applying CSP and permission metadata, computing the content hash, and surfacing the resource on the next resources/list.

To inline the full OWL bundle (so the app can render real Odoo views), set inline_app_bundle=True on the resource record. Set app_bundle_name to muk_mcp_apps.spreadsheet_bundle if the app needs the o_spreadsheet runtime as well.

Security

• Bundle isolation — every resource runs in a sandbox iframe with sandbox="allow-scripts allow-same-origin". CSP, permissions, and border preferences are declared per-app in _meta.ui.
• Auth never crosses the iframe — the API key stays in the host; web_proxy attaches the session server-side.
• Standard MCP gating applies — Bearer token, scope (Read Only vs Read & Write), Odoo record rules, and the audit log all run on every proxied call.
• Path-prefix allow-list — only assets from modules in the muk_mcp_apps dependency closure are inlined into the bundles, so unrelated module assets (mail, hr, account, …) never reach the iframe.

Credits