# uxgen (remote · www.uxgen.ai)

Ecommerce conversion for coding agents: AOV bundles, cart, upsell, imagery, page audit.

- Trust score: 81/100 (high trust)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

## Components

- remote · `www.uxgen.ai`: 81/100 (this document), [markdown](https://verifymcp.io/servers/ai-uxgen-ecommerce-conversion/www.md), [page](https://verifymcp.io/servers/ai-uxgen-ecommerce-conversion/www)

## Channel facts

- Endpoint: `https://www.uxgen.ai/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-20.

- **Endpoint Security**: 94/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation is enforced on tool calls, advertised via RFC 9728 protected-resource metadata. Discovery is public, which costs nothing: no tool can be invoked without a token.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
  - The authorisation server offers only Dynamic Client Registration (RFC 7591), which MCP 2026-07-28 deprecated in favour of Client ID Metadata Documents.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 50/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 5940 tokens (~424/item across 14 items; 14 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 63/100
  - Stability check failed: schema churn in the 26 days we've observed: 0 tool removals, 4 breaking changes, 0 auth/transport breaks, 5 additions.
- **Tool Coverage**: 67/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 14 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 15 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the uxgen MCP server?

uxgen is a hosted endpoint at https://www.uxgen.ai/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http ai-uxgen-ecommerce-conversion 'https://www.uxgen.ai/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "ai-uxgen-ecommerce-conversion": {
      "url": "https://www.uxgen.ai/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ai-uxgen-ecommerce-conversion": {
      "type": "http",
      "url": "https://www.uxgen.ai/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.ai-uxgen-ecommerce-conversion]
url = "https://www.uxgen.ai/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ai-uxgen-ecommerce-conversion": {
      "type": "remote",
      "url": "https://www.uxgen.ai/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ai-uxgen-ecommerce-conversion --url 'https://www.uxgen.ai/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  ai-uxgen-ecommerce-conversion:
    url: "https://www.uxgen.ai/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "ai-uxgen-ecommerce-conversion": {
      "Transport": "http",
      "Url": "https://www.uxgen.ai/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add ai-uxgen-ecommerce-conversion -t streamable-http -u 'https://www.uxgen.ai/mcp'
```

### Other

```json
{
  "mcpServers": {
    "ai-uxgen-ecommerce-conversion": {
      "type": "http",
      "url": "https://www.uxgen.ai/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-20 (score 81, +1)

- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

### 2026-09-19 (score 80, 0)

- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

### 2026-09-18 (score 80, +1)

- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

### 2026-09-17 (score 79, 0)

- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

### 2026-09-16 (score 79, +1)

- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

### 2026-09-15 (score 78, 0)

- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

### 2026-09-14 (score 78, 0)

- [functional regression] Schema quality: 353 → 424
- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

### 2026-09-13 (score 78, +1)

- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

## MCP tools (14)

### `uxgen_brief` (~629 tokens)

Brief — the design law, the trade contract, the path

TWO MODES, AND `improve` IS THE DEFAULT WHENEVER THE MERCHANT ALREADY HAS A STORE. `mode: "improve"` — their page is KEPT: the theme is inherited (`uxgen_theme` with `heriteDe`), `uxgen_audit` runs in conservation (`conserver: true`) and returns only what can be ADDED at an anchor or FIXED in place, each addition is inserted with `uxgen_piece` at the anchor the audit names, and a per-section diff (kept / changed / added) is shown before `uxgen_publier`. There is no « write the page » step. `mode: "rebuild"` — the construction path below. THE RULE WHEN `mode` IS NOT GIVEN: improve when `idea` says a site EXISTS (« existing », « already have », « keep », « don't rebuild », « j'ai déjà », « my store is at <URL> »); rebuild when a NEW store is the request (« build / create my store », « a brand-new site », « I don't have a store yet ») or when asked for in those words (« rebuild », « from scratch »). A new-store request wins over the possessive: « build my store » = rebuild, « improve my store » = improve. The answer names the mode and the words that decided it.

CALL THIS FIRST for any page or site you are about to build, before writing a single line. It takes the user's own sentence and returns (a) the full text of the design law, (b) the CONTRACT for that trade — what has to be present, and the objection each presence kills, (c) the commerce-kit verdict, which DECIDES which mechanics apply given the nature of the object, (d) the proposed theme, (e) the seven-step path. 🚨 IT RETURNS NO PAGE PLAN AND NO BLOCK IDS, deliberately: a default plan once produced the same page for five unrelated trades. Structure, composition and the graphic gesture are YOURS; the page is written by hand. Calling this tool after you have started coding is good for one thing only: surveying the damage.

Input parameters:

- `adjective` (string)
- `ancre` (string)
- `benefice` (string)
- `brandName` (string)
- `cadeau` (boolean)
- `color` (string)
- `concurrent` (string)
- `coutReel` (string)
- `idea` (string, required)
- `intention` (string)
- `mode` (string)
- `nature` (string)
- `objection` (string)
- `offre` (string)
- `out` (string)
- `plainte` (string)
- `preuves` (string)
- `prixUnitaire` (number)
- `probleme` (string)
- `projectDir` (string)
- `styleId` (string)
- `trafic` (string)
- `verbatims` (string)
- `vertical` (string)

### `uxgen_theme` (~488 tokens)

Theme — OKLCH palette, fonts, radii, motion

THE LOCKED GRAMMAR — call it right after `uxgen_brief` and BEFORE the first tag. Its CSS is pasted as is at the top of the page and is not retouched: that is what stops two dark grounds stacking.

🛒 THE COMMERCE KIT. Pass `commerce` and the kit is BUILT: you get back TWO VERSIONED URLS with their `integrity` — a `<link>` and a `<script>` to paste — plus the marking contract. The kit holds the buying path BY CONSTRUCTION (cart, drawer, quantity, total, free-shipping threshold, delivery date, a button that carries its amount) — it is the answer to a `uxgen_audit` that refused the transaction.

⚠️ WHY URLS AND NOT BYTES. The two files are the SAME for every merchant — measured, not assumed: the kit carries no merchant data at all, your configuration lives in your page's `<script data-ux-commerce>` tag. Sending them as text cost 400 KB (~100 000 tokens) of YOUR context, every time, for a constant. Pass `kit: true` to get the bytes anyway — for an offline page, or one that must not fetch anything at runtime.

Turns a brand color and an adjective into a COMPLETE set of CSS variables: palette (3 roles + 2 derived), font pair, radii, shadows, rhythm, motion. Works in OKLCH, holds WCAG contrast, and corrects luminance when a pair fails. CALL IT RIGHT AFTER uxgen_brief AND BEFORE THE FIRST TAG, then run it again as soon as the client gives their real color. Its CSS is pasted AS IS at the top of the page and never touched up: that is what stops two dark grounds from stacking. ⚠️ YOU MUST PASS "color" OR "paletteId": "adjective" alone is REFUSED.

Input parameters:

- `adjective` (string)
- `autonome` (boolean)
- `color` (string)
- `commerce` (object)
- `da` (string)
- `fontId` (string)
- `heriteDe` (string)
- `intention` (array)
- `kit` (boolean)
- `name` (string)
- `paletteId` (string)
- `produit` (string)

### `uxgen_image` (~440 tokens)

Image — the material of the page: scene or packshot, generated, framed, written

THE MATERIAL OF THE PAGE — scene OR packshot. Start with `emploi` and `categorie`: two words, and the prompt is written to the codes of that sector (background, light, human presence, set density, a quiet zone measured for the headline). 🚨 IT DOES NOT ONLY DO PACKSHOTS: a free `prompt` + `cutout: false` produces THE SCENE (dining room, consulting room, workbench, shopfront) — the trades with no object to cut out need exactly that. `cutout: true` = the cut-out packshot chain. It writes the image to disk, cut out once, trimmed, framed to the ratio, in WebP, and returns the <img> tag with its real dimensions. LIGHTING IS GRADED AND MEASURED AUTOMATICALLY: do not write "soft light" or "cream background", you would switch back on what the chain switches off. The details of the grading, of the uses and of the categories are returned IN THE RESPONSE.

Input parameters:

- `adjective` (string)
- `ambiance` (boolean)
- `aspect` (string)
- `blockId` (string)
- `brandName` (string)
- `categorie` (string)
- `color` (string)
- `controlerMarque` (boolean)
- `controlerSujet` (boolean)
- `cutout` (boolean)
- `emploi` (string)
- `essais` (number)
- `heros` (object)
- `mentions` (array)
- `name` (string)
- `out` (string)
- `outDir` (string)
- `photo` (string)
- `projectDir` (string)
- `prompt` (string)
- `registre` (string)
- `ressemblance` (boolean)
- `sansTexteSurObjet` (boolean)
- `serie` (string)
- `slot` (string)
- `styleId` (string)
- `subject` (string, required)
- `surface` (string)
- `variables` (object)

### `uxgen_render` (~375 tokens)

Render — screenshots on disk, to be LOOKED AT

RENDERS YOUR PAGE AND GIVES YOU THE IMAGES BACK, in this response — nothing is written to any disk. Send `html` (the page content, as text) or `url`. You get the first screen and the full page at 390 and 1440 px, as real images you must OPEN and LOOK AT before you change anything. A page that was never looked at is the first cause of an ugly site.

⚠️ THE 8-FRAME SCROLL STRIP IS NOT RETURNED BY DEFAULT: measured at 698 KB for a text-only page, several MB for a real one. Ask for it with `bande: true` and it is served up to a hard weight cap, which the answer states.

⏱ Expect 10 to 25 seconds.

MAKES THE PAGE VISIBLE. Call it as soon as the page is assembled, and after every visual fix, BEFORE the audit. It opens the page in headless Chrome (no server left running) and WRITES TO DISK: the first screen alone, the full page, and a strip of 8 frames captured during a scripted scroll, at 390 and 1440 px. It also returns what a screenshot cannot show: horizontal overflow per width, approximate LCP, transferred weight, images without dimensions. THE PATHS IT RETURNS MUST BE OPENED WITH YOUR IMAGE-READING TOOL: this tool does not judge for you, it hands you the view. Writing a page you never look at is the number one cause of ugly sites.

Input parameters:

- `bande` (boolean)
- `frames` (integer)
- `html` (string)
- `scrollWidth` (integer)
- `timeoutMs` (integer)
- `url` (string)
- `widths` (array)

### `uxgen_audit` (~584 tokens)

Audit — the law applied mechanically, gaps named

MEASURES A PAGE FOR REAL, IN HEADLESS CHROME, ON THIS SERVER — five widths (360, 390, 768, 1100, 1440), the computed styles, the scroll, and a robot that CLICKS the buying path. Send `html` (the page content, as text) or `url` (a live page). It writes NOTHING anywhere: it returns named gaps, each with the selector and the gesture that closes it, and NO score to chase.

⏱ EXPECT 45 TO 65 SECONDS. Measured 25/08 on a 2 KB page: 47 s at five widths. This is not a hang — do not retry, and tell your user it is running.

🧷 `conserver: true` — THE AUDIT OF A PAGE YOU KEEP (default after a brief in `improve` mode). It returns only what can be ADDED (a missing mechanic, each with its ANCHOR: « after the buy box », « before the footer ») or FIXED in place (a dead link, an image without dimensions, an illegible text). The rebuild families — canon sequence, grounds, radii, header grid, typography, signature gesture, animations, page length — are set aside, and the report says how many and which. It never points you to a tool this server does not run: an absent part is added with `uxgen_piece` at its anchor.

MEASURES the page and RETURNS NAMED GAPS. A real audit in headless Chrome at 360, 390, 768, 1100 and 1440 px, on a block (`blockId`), an HTML file (`path`) or a URL (`url`). It returns the profile it used and every gap with its SELECTOR, its WEIGHT and THE GESTURE that closes it, most expensive first. 🚨 AUDIT THE PAGE, NOT THE BLOCKS: colors, radii, breathing room and distance to the price only show up on the assembled page. 🚨 NO SCORE, NO THRESHOLD, NO GO-AHEAD, and that is deliberate: nothing to clear, nothing to push up. YOU are the one who decides to ship, after LOOKING at the screenshots. Fix by the GESTURE the gap names, never by pushing a number. The response stays under 10,000 characters and SAYS what it leaves out; the full report is written next to the page in `_bloom-audit/`.

Input parameters:

- `arbitrage` (array)
- `complet` (boolean)
- `conserver` (boolean)
- `html` (string)
- `profil` (string)
- `timeoutMs` (integer)
- `transaction` (boolean)
- `url` (string)

### `uxgen_ameliorer` (~440 tokens)

Improve — the first screen judged by an outside eye that does not know which one is new

⛔ NOT AVAILABLE ON THIS HOSTED SERVER — do not call it, it will refuse. WHAT IT DOES WHERE IT RUNS: it ADJUSTS THE CSS OF ONE SECTION — one to five scoped rules — and NEVER ADDS A SECTION. It is not the tool that adds a missing mechanic. WHY IT REFUSES HERE: its judge is a VISION MODEL and no vision key is configured, and its engine is not deployed on this server; a tool that "improves" a page without looking at it would be inventing its corrections. TO IMPROVE AN EXISTING PAGE: `uxgen_brief` in `improve` mode, then `uxgen_audit` with `conserver: true` — it names what to ADD and where — and `uxgen_piece` at the anchor.

🎯 THE ONLY EXTERNAL JUDGE IN THE PRODUCT, ~30 SECONDS BY DEFAULT. It is the only piece of the chain that says whether the page is BEAUTIFUL — uxgen_audit only says whether it is clean. At scope "pli" (THE DEFAULT) it judges the first screen at 390 px only: 2 to 3 vision calls, ~0.004 $. `portee: "page"` takes the whole page: ~50 calls, 20 to 40 minutes. HOW IT JUDGES: each section is captured ALONE and submitted to an external vision model that returns NO SCORE — what is wrong, what it costs, and the CSS gesture with its values. The gesture is applied, the section recaptured, and both images go back to the judge IN A RANDOMISED ORDER: if it does not pick the new one, THE GESTURE IS REVERTED. ⚠ LOOK AT THE before|after BOARDS it writes, with your image-reading tool, before you announce anything at all.

Input parameters:

- `largeurs` (array)
- `metier` (string)
- `modele` (string)
- `portee` (string)
- `sansCroiser` (boolean)
- `timeoutMs` (integer)

### `uxgen_status` (~177 tokens)

Status — resume a build already started, or diagnose a refusal

🚨 DO NOT CALL THIS TO GET YOUR BEARINGS: the path is returned by uxgen_brief, and this response is LONG (~5,500 tokens; "complet" makes it ~14,700). Two uses, and only two. (1) RESUME a build already started: with "projectDir" it reads bloom.json and returns the brand, the committed style, the images produced, the current step — the answer to "where were we?" without asking anything again. (2) DIAGNOSE a refusal: licence and tier, credits left, whether the image key is present, manifests in error. When a tool refuses to run, the cause is here. On a brand-new page, this call teaches you nothing.

Input parameters:

- `complet` (boolean)
- `projectDir` (string)

### `uxgen_packshot` (~411 tokens)

Packshot — the brand label on a real photograph

PUTS THE BRAND'S OWN LABEL ON A PRODUCT SHOT, and returns the produced image IN THIS RESPONSE — nothing is written to any disk. Send the photograph as `photoBase64` (raw base64, no `data:` prefix) or `photoUrl`. It checks the subject really is that product and REFUSES a dirty result rather than shipping it.

COMPOSES THE CLIENT'S PRODUCT ONTO A REAL PHOTOGRAPH. It takes a studio photograph of a container with a BLANK WHITE label, detects the edges of that label at pixel level, and inlays the brand's label with a `multiply` blend: the drop shadow and the curve of the cylinder pass through the artwork, so the jar stays believable.

THE FONT IS MANDATORY AND IT IS THE SITE'S FONT. No fallback — with no font, no brand or no ink, the tool REFUSES rather than printing something generic.

🚨 IT TAKES TWO CALLS. First call without `zone`: it detects, writes the proof image (magenta rectangle) and REFUSES, handing you the four numbers. You OPEN the proof. Second call with `zone`: it composes. Detection on its own mistakes a label for a blank screen or a tablecloth — composing without looking means printing the brand onto a scrap of tablecloth.

🚨 The label lives INSIDE the image, never on top of it: an HTML text overlay laid over the photo to fake a label is a named gap (V3, uxgen_audit).

Input parameters:

- `courbureDeg` (number)
- `encre` (string, required)
- `fond` (string)
- `lignes` (array)
- `marque` (string, required)
- `photoBase64` (string)
- `photoUrl` (string)
- `policeDisplay` (string, required)
- `policeHref` (string)
- `preuve` (boolean)
- `surtitre` (string)
- `zone` (object)

### `uxgen_publier` (~518 tokens)

Publish — the refusal lands on the FILE, not on a warning

THE LAST GATE BEFORE YOU ANNOUNCE IT IS DONE — and on this hosted server it PUBLISHES NOTHING: it returns the verdict and the CONTENT to write, and YOU write the file. Send `html`. It refuses a page that carries a third party's legal identity, an invented customer review, an invented activity figure, a hand-redrawn third-party logo, two different current prices for one product, or two different dark grounds.

🔴 IT NOW REQUIRES THE RENDER SEAL. Call `uxgen_render` on the EXACT html you are about to publish, OPEN the images, then pass its `rendu` field back here unchanged. Without it the page is REFUSED — until today the absence of render data DISARMED the checks instead of refusing, which is the opposite of a guard rail. A page assembled outside the chain (taken from the merchant site, hand-written) passes with a written `motifHorsChaine`: a written reason passes, silence does not. ⚠️ The seal proves the RENDER happened on this page, never that anyone LOOKED at it.

A refusal is not a failure of the tool: it names the reason, and the content it returns is then a DRAFT — write it to a `.brouillon.html` with a noindex, never to the publishable path.

CALL THIS BEFORE ANNOUNCING THAT IT IS DONE, on the page you have just written. It refuses to write the page to the publishable path if it carries a third party's legal identity, an invented customer review, an invented activity statistic, a THIRD-PARTY BRAND LOGO REDRAWN BY HAND, two different current prices for the same product, or two different dark grounds.

A refusal destroys nothing: the draft goes to ".brouillon.html" with a noindex, and whatever already sat at the publishable path stays INTACT.

🛒 A MULTI-ITEM SHOP HAS TO BE DECLARED: as soon as the page carries the commerce configuration written by `uxgen_theme` (two real items or more), prices are counted PRODUCT BY PRODUCT. This is not an exemption: WITHIN one product, two current prices reject the page exactly as they would on a single-product page. With no…

Input parameters:

- `fonds` (array)
- `force` (boolean)
- `hauteurs` (array)
- `html` (string, required)
- `nom` (string)

### `uxgen_seo` (~201 tokens)

Turns one seed keyword into an SEO PLAN built on live Google data: the keywords around it, their monthly traffic, their difficulty, who currently holds the top of each result page, and what to write to take it. It is a plan, not a report: every target comes back with the format Google is already rewarding on that query, read from the live result page rather than guessed. The search-data key lives on the uxgen server and never reaches you: you call this tool, the server calls the provider. Included from the Pack plan upwards, with a monthly allowance in dollars; one plan costs about 0.020 $ of it. When that allowance or the platform budget is spent, the refusal says so, says when it reopens, and carries `reessayable`: it is a decision, not an outage, and everything else on uxgen keeps working.

Input parameters:

- `graine` (string, required)
- `marche` (string)

### `uxgen_piece` (~152 tokens)

One part of the library, in the format your target wants: `format:"html"` (default) gives the self-contained HTML and the prompt that built it; `format:"liquid"` gives the SAME part as a Shopify theme section — {% schema %}, settings, presets — with the filename it goes under and the template entry to write. Give the id `uxgen_catalogue` showed you (CAPTCHA-01, PANIER-03...). Free accounts open 10 parts; a paid plan opens all 173. A locked part answers with a refusal that carries the checkout link: it is a decision, not an outage.

Input parameters:

- `format` (string)
- `id` (string, required)

### `uxgen_demarrer` (~195 tokens)

⚠️ REMOTE SERVER — THE RECIPE COMES BACK IN THE ANSWER, IT IS NOT WRITTEN TO YOUR DISK. Read it, fill it with your file editor, and pass it back to `uxgen_poser` as `recette`. Everything below is true of this tool; only the delivery differs.

PREMIER GESTE, avant toute ligne de code : donnez la phrase du client telle quelle, sans rien lui demander de plus. Rend le squelette choisi, l’univers de couleur, et un gabarit de recette sur disque où il ne reste que des textes à remplacer.

Input parameters:

- `brief` (string, required)
- `fiches` (string)
- `langue` (string)
- `marque` (string)
- `produits` (array)
- `projet` (string)
- `squelette` (string)
- `univers` (string)

### `uxgen_poser` (~236 tokens)

⚠️ REMOTE SERVER — SEND THE FILLED RECIPE AS TEXT, GET THE ASSEMBLED PAGE AS TEXT. It has no access to your disk: you send `recette`, you receive the complete HTML and you write the file. Bank photographs come back as absolute URLs on https://www.uxgen.ai — the page works the moment you save it, nothing to download. Everything below is true of this tool; only the delivery differs.

DEUXIÈME GESTE, après avoir rempli la recette rendue par uxgen_demarrer. Assemble la page et la contrôle. Rend le chemin de la page et les écarts : textes trop longs, clés introuvables, fragments figés, textes de démonstration restés. Rappelez-le autant de fois que vous corrigez un texte — une repose ne coûte rien et ne décompte rien. Ensuite : `uxgen_render`. ⏱ compte 15 à 20 secondes, c’est normal : il assemble, ouvre la page et la capture.

Input parameters:

- `projet` (string, required)
- `recette` (string, required)

### `uxgen_catalogue` (~68 tokens)

La vitrine. Sans argument : les rôles disponibles. Avec un rôle : les pièces de ce rôle. Ne servez-vous-en que si le client demande autre chose que ce que le squelette a posé.

Input parameters:

- `metier` (string)
- `role` (string)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ai-uxgen-ecommerce-conversion/www#diagnostics

## Score history

- 2026-09-20: 81
- 2026-09-19: 80
- 2026-09-18: 80
- 2026-09-17: 79
- 2026-09-16: 79
- 2026-09-15: 78
- 2026-09-14: 78
- 2026-09-13: 78
- 2026-09-12: 77
- 2026-09-11: 77
- 2026-09-10: 76
- 2026-09-09: 76
- 2026-09-08: 76
- 2026-09-07: 75
- 2026-09-06: 75
- 2026-09-05: 74
- 2026-09-04: 25
- 2026-09-03: 25
- 2026-09-02: 25
- 2026-09-01: 25
- 2026-08-31: 72
- 2026-08-30: 72
- 2026-08-29: 72
- 2026-08-28: 72
- 2026-08-27: 72
- 2026-08-26: 72
- 2026-08-25: 70

## Common questions

### What is the uxgen MCP server?

uxgen is an MCP server listed in the public MCP registry as ai.uxgen/ecommerce-conversion. Ecommerce conversion for coding agents: AOV bundles, cart, upsell, imagery, page audit. This page covers its hosted endpoint (https://www.uxgen.ai/mcp).

### Is the uxgen MCP server safe to use?

uxgen scores 81 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the uxgen MCP server expose?

uxgen exposes 14 tools: uxgen_brief, uxgen_theme, uxgen_image, uxgen_render, uxgen_audit, and 9 more. Their descriptions and schemas cost roughly 4,914 tokens of context every time the server is loaded.

### Does the uxgen MCP server require authentication?

Yes. uxgen asked us for credentials when we connected, so you will need to authorise it in your MCP client before it can do anything.

### Is the uxgen MCP server still maintained?

uxgen is still listed as active in the MCP registry. We last reached this channel on 20 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://www.uxgen.ai/mcp
- Website: https://www.uxgen.ai/mcp
- Changelog RSS feed: https://verifymcp.io/servers/ai-uxgen-ecommerce-conversion/www.xml
- Changelog JSON feed: https://verifymcp.io/servers/ai-uxgen-ecommerce-conversion/www.json
- HTML version of this page: https://verifymcp.io/servers/ai-uxgen-ecommerce-conversion/www