Skip to main content
Glama
565,393 tools. Updated 2026-09-14 09:56

"ICON" matching MCP tools:

  • MANDATORY FIRST CALL before writing any @marmoui/ui code in this session. Returns a step-by-step generation checklist (which tools to call, in what order), critical rules (no namespace sub-components, PageSection is self-closing, no Sidebar export), component patterns, and ICON LIBRARY RULES. Pass iconLibrary (default "phosphor"; also "material" | "lucide" | "tabler" | "heroicons" | "feather") to get that library's import source, icon name map, and weight/style mapping — and pass the SAME value to review_generated_code so it enforces it. Ask the user which icon library they want before writing UI code. Call topic="patterns" to get the generation checklist specifically.
    ConnectorNo auth
  • MANDATORY FIRST CALL before writing any @marmoui/ui code in this session. Returns a step-by-step generation checklist (which tools to call, in what order), critical rules (no namespace sub-components, PageSection is self-closing, no Sidebar export), component patterns, and ICON LIBRARY RULES. Pass iconLibrary (default "phosphor"; also "material" | "lucide" | "tabler" | "heroicons" | "feather") to get that library's import source, icon name map, and weight/style mapping — and pass the SAME value to review_generated_code so it enforces it. Ask the user which icon library they want before writing UI code. Call topic="patterns" to get the generation checklist specifically.
    ConnectorNo auth
  • Get a product's full, LLM-verified design system so you can match its exact look. Use this for "design like <product>" (e.g. site="Linear", "Stripe", "Figma"). Returns (default): color_scheme; colors with named roles (background, text, primary, secondary, accent, link, button_bg, button_text); fonts + font_roles; type_scale; spacing; primary/secondary button; framework + personality. All hex normalized. Deep-decoded products additionally include measured button hover/focus states, a shadow elevation scale (card/overlay/subtle), motion durations + easings, the measured spacing scale, the brand's own CSS custom properties (css_vars), and Icon DNA (icons: style outline/filled/duotone/3d, grid, stroke_weight, corner) — all measured from the live page, not guessed. Match them exactly; pass the domain to generate_asset(style_from=...) to strike icons in this exact style. Your own private BYODS design systems (call list_my_design_systems) resolve first. format: leave empty for the raw token dict. Pass "all" to also get paste-ready DESIGN.md / Tailwind v4 / CSS variables / W3C tokens JSON, or a single format name ("tailwind", "css", "design_md", "tokens", "astryx") to get just that text. "astryx" returns a ready Meta-Astryx defineTheme TypeScript file (measured hover/press states + [light,dark] tuples baked in) — save it and run `npx astryx theme build` for production CSS.
    ConnectorNo auth
  • Configure this share — its name and its **appearance** — fields you don't pass stay as they are (server-side partial merge). - `label`: the name at the top of the chat page, and the browser tab's title. **Renaming a share is this call**; you never need to create a replacement and delete the old one. That would mint a new token, so the link already embedded in the client's site would stop working — the visible name and the address are not the same thing. - `theme_color`: the brand colour, `#RGB` or `#RRGGBB`. **This one colour is all you give** — its foregrounds are derived on save. - `highlight_color`: **only if the brand actually has a second colour.** Most don't; leave it out and nothing changes anywhere. When set, it is used where something should be visible without competing with the primary action: the second series in a chart, and citation markers. Buttons, the current storyline step and user bubbles stay on `theme_color` — two colours fighting over the same element is how a two-colour palette goes wrong. Foregrounds are derived from it the same way. Text/foreground colours are derived server-side to WCAG contrast and stored (a light brand colour automatically gets dark text instead of white) — **do not compute a palette yourself and do not try to set text colours**; they would be overridden. - `logo_url`: absolute URL. The header scales by height, any aspect ratio fits; **the collapsed launcher bubble is square**, so only near-square images (aspect 0.74–1.35) are used on the bubble — a wide wordmark falls back to the platform icon there. Want your mark in both places? Provide a square variant too. - `input_mode`: `text` (text box, default) or `voice` (opens in push-to-talk). Requires the platform's voice backend. - `launcher`: hover tooltip text for the bubble. `theme`: `light` / `dark` / empty = follow the visitor. - `custom_css`: the escape hatch for strict brand guidelines — the injected stylesheet can override our CSS variables (`--acc` / `--acc-fg` / `--acc-text-l` / `--acc-text-d` / `--bg` / `--surface` / `--text` / `--border`); write light values under `:root{…}` and dark under `html[data-theme="dark"]{…}`. **Prefer theme_color**: it carries a readability guarantee, with custom_css the contrast is on you. Get the token from `list_shares` first. Full examples in the Cookbook's configure-branding.
    ConnectorNo auth
  • Add (or remove) Orivox's accessibility widget: a floating accessibility button that appears on EVERY page of the site and opens a toolbar of reader aids for visitors. Reach for this the moment the user asks for an accessibility button, an accessibility menu or toolbar, or says their site should be accessible / usable with a screen reader / compliant -- this one call installs the whole thing. Do NOT hand-build an accessibility widget with apply_dom_ops. ``icon`` picks the button's glyph: "person" (default, the standard accessibility figure), "wheelchair", or "user". ``position`` puts it at the bottom "right" (default) or bottom "left" of the screen. Calling this again with different options REPLACES the existing widget instead of adding a second one, so it is also how you change the icon or move it to the other side. ``action="remove"`` takes it off the site entirely. ``changed`` is byte-honest: False means NO file was written at all, because the site already looked exactly like this -- do not announce a fresh change. True means at least one file was rewritten. ``outcome`` says which end state you are in; describe it to the user IN THEIR OWN LANGUAGE (never echo these tokens): - "installed" -- the widget is now on every page with the given icon/side. - "already_installed" -- it was already exactly like that; nothing changed. - "removed" -- it is off the site. - "was_not_installed" -- there was none, so there was nothing to remove. - "install_not_confirmed" / "removal_not_confirmed" -- the result contradicts itself. ``verify_before_reporting`` is true for these two: check the site with get_preview_url before telling the user anything about the widget, and do not claim success or failure. No re-publish is needed for a preview, but a LIVE site only shows the widget after publish_website runs again.
    ConnectorOAuth
  • Discover the vocabulary for building a product rule (an attribute-value transformation — the feature Koongo's UI and help call "Attribute Rules" / "Rules"). GUARDRAIL: a Rule must never be keyword-matching — if a value would need MORE THAN 3 text-`contains` conditions to derive (color, material, gender… from free text), STOP and enrich per-product with set_api_source/set_ai_source instead of building the Rule. A Rule patches FEED OUTPUT only and writes NOTHING onto the products; if the user asked to enrich the products, use set_api_source/set_ai_source (or ask first) — never substitute a Rule. Call this FIRST, before you write a rule, so you use only supported operations, conditions and arguments. Returns {operations:[{name, label, group, returnType, valueType, math, attributeVariant, arguments:[{name, label, type, required, options, placeholder, optionsSource}]}], conditions:[{operator, label, group, disabledFor, arguments}], ruleSchema, examples:[{title, description, rule, sampleProduct, expectedValue}]}. A rule document has the shape {name, description, category, icon, rules:[...]}. Each rule is {sortId (int, precedence — the server reassigns it 1,2,3… by position on save), enabled (bool), type, conditions (a condition tree, optional), operationGroups:[{mode, parentMode, attributes:[...], operations:[{name, arguments:{key:value}}]}]}. A rule's `conditions` (when present) is a combine node {type:"combine", operator:"and"|"or", conditions:[ {type:"expression", attribute, operator, value} | nested combine]} — a single condition is a combine wrapping one expression, and the comparison value always goes in the expression's `value` (an operator's arguments only describe that value's input). AUTHOR the unconditional "Default Rule" FIRST, then the "Conditional Rule" exceptions — the server normalizes to that shape and reassigns sortId 1,2,3…; among conditionals a lower sortId is evaluated first and the Default Rule (at most one) is the fallback. Match a condition value's type to its attribute: a numeric attribute (dataType integer/double from list_source_attributes) needs a NUMBER not a quoted string (the server casts on save), and a text operator (disabledFor includes "number": contains/starts_with/ length_exceeds/*_any/…) on a numeric attribute is REJECTED — use greater/less/equals instead. Operations in a group run left-to-right and chain by type: an op's valueType is its INPUT and returnType its OUTPUT, so each op's returnType must match the next op's valueType. The Rules help's text "Functions" (trim, upper/lower case, strip HTML, base64…) are the single textoperations operation via its function argument; collection "Functions" (sort, unique, join, first non-empty…) are the Collections-group operations. An operation's `arguments` object keys come from that operation's argument spec here; enum arguments accept only the listed options ids. Filter to one operation group with `group`; set detail 'full' for the complete argument specs and 'compact' (default) for a lighter list. include_conditions adds the condition operators; include_examples adds curated end-to-end worked examples. VALUE / OPTIONS MAPPING (the map_attribute_value operation) remaps a source attribute's store values onto a target/channel attribute's allowed set (the CP "store value → channel value" table). Its search and replace arguments are ARRAYS OF OBJECTS {value:'<string>'} paired by index (search[i] → replace[i], SAME length) — NOT plain-string arrays. Plain strings save without error but map nothing (empty rows in the UI, passthrough at runtime) — the #1 gotcha. replace is OPTIONAL (the CP "AI Mapping (unmapped)" autofills the rest) but provide it for deterministic output. A source value NOT listed in search passes through UNCHANGED (no implicit default), so for a CLOSED target allowed-value set either map EVERY value or add a Default Rule (set_value) fallback, otherwise unmapped values violate the channel spec. Place it in an operationGroup with mode:'single', attributes:['<source code>']. SET OPTION (the setoption operation) assigns an attribute a fixed value from its CLOSED option list: put it in an operationGroup mode:'set_option', attributes:[], operations:[{name:'setoption', arguments:{value: '<option value>'}}] — value is the option VALUE, not its label. More generally, an argument whose spec has optionsSource (e.g. 'feedAttribute') means its value must be one of the target attribute's options — read them with get_attribute_options. ALWAYS validate_rule a rule before create_rule / update_rule.
    ConnectorOAuth

Matching MCP Servers

  • A
    license
    A
    quality
    D
    maintenance
    A Model Context Protocol (MCP) server for semantic SVG icon search. Generate infographic SVG icons by keyword — over 100,000 icons with semantic search support.
    1
    8 npm
    MIT
  • A
    license
    A
    quality
    D
    maintenance
    Provide access to Iconify's MCP server with over 200,000 open-source vector ICONS, supporting icon set browsing, searching, and obtaining multi-framework usage examples.
    4
    2
    Apache 2.0

Matching MCP Connectors

  • MEOK EU AIGC Icon MCP — EU AI Act Article 50 + Code of Practice 2nd draft AI-generated-content icon

  • Find semantic Digche replacements for functional UI icons and retrieve the selected SVG style.

  • Validate a product rule (Attribute Rule) WITHOUT saving it. ALWAYS call this before create_rule / update_rule and fix every error first. Pass the full rule document as `rule` — {name, description, category, icon, rules:[{sortId, enabled, type, conditions, operationGroups:[{mode, parentMode, attributes, operations: [{name, arguments:{key:value}}]}]}]} (see discover_rule_operations for the operation/condition/argument vocabulary). Returns {valid, errors:[{path, code, message}], warnings:[{path, code, message}], dryRun}. Errors are blocking — the rule will be rejected on save; warnings are advisory. If you also pass a sample_product (a flat {attributeCode:value} record, e.g. from preview_products) and the rule is structurally valid, the server dry-runs it and returns dryRun:{matchedRuleSortId, computedValue, usedAttributes} so you can confirm the output before saving. This tool NEVER writes. project_id is OPTIONAL (inferred for a single-project customer; project_id_required otherwise — then call list_projects). When you do NOT pass sample_product, the server auto-samples a real product to compute dryRun, so the computedValue is real data returned only after you set acknowledge_sensitive:true: the first such call (flag absent/false) returns {sensitiveGate:{confirmationRequired:true, itemCount, fields, kind}} with the computedValue EMPTY — present that gate to the USER, get their approval, then re-call with acknowledge_sensitive:true. (If you passed your own sample_product you already hold that data, so no gate applies and the computedValue is returned directly.) DRY-RUN LIMITATION: AI-group operations — notably map_attribute_value (value/options mapping) — are NOT executed by the dry-run. It returns valid:true with computedValue = the input UNCHANGED (passthrough) even when the mapping is correct; this is expected, not a bug, so do NOT treat the unchanged value as a failure. Verify a value/options mapping only AFTER a real build/export: feed → export_feed then verify_feed_attributes; marketplace/ad → repair_marketplace / run_marketplace_operation (or the ad equivalents) then get_*_report.
    ConnectorOAuth
  • Create a NEW product rule (an Attribute Rule). GUARDRAIL: a Rule is NEVER a substitute for per-product enrichment — if you would need MORE THAN 3 text-`contains` conditions (contains/contains_any/starts_with on a description/title) to derive a value (color, material, gender…), do NOT create a Rule; enrich instead with set_api_source/set_ai_source and map that source attribute (see the server ENRICH guidance). A Rule patches FEED OUTPUT only and writes NOTHING onto the products; if the user asked to enrich the products / add attribute X to the products, use set_api_source/set_ai_source (or ask first) — never substitute a Rule. ALWAYS validate_rule it first and fix every error. Pass the full rule document as `rule` — {name, description, category, icon, rules:[{sortId, enabled, type, conditions, operationGroups:[{mode, parentMode, attributes, operations:[{name, arguments:{key:value}}]}]}]} (see discover_rule_operations for the vocabulary). Any _id/id you include is IGNORED — the server always mints a new one (this tool never overwrites an existing rule; use update_rule for edits). `scope` selects where it is created: 'project' (default) = the project's own library; 'shared_template' = the reusable shared template library (a template_read_only error means your access cannot write there). Returns {ruleId, scope, status, changed, reason, validation}; status 'created' on success, or 'rejected' with the validation errors when the rule is invalid (HTTP 200, nothing written). SAVE-ONLY: a new rule has NO effect on any feed until you attach it to a feed attribute with map_feed_attribute (rule_id) and then export_feed; a shared_template rule affects no feed at all until it is used by a project. VALUE/OPTIONS MAPPING: for a map_attribute_value operation, search and replace are arrays of {value:'<string>'} objects paired by index (NOT plain strings — plain strings save but map nothing, showing empty rows); replace optional. That op is not executed by validate_rule's dry-run (passthrough computedValue) — verify only after a real export/build. project_id is OPTIONAL (inferred for a single-project customer; project_id_required otherwise — then call list_projects).
    ConnectorOAuth
  • Update an EXISTING product rule (Attribute Rule). ALWAYS validate_rule the new document first and fix every error. Identify the rule by rule_id (from list_rules / get_rule) and pass the full rule document as `rule` — {name, description, category, icon, rules:[{sortId, enabled, type, conditions, operationGroups: [{mode, parentMode, attributes, operations:[{name, arguments:{key:value}}]}]}]}. The safe pattern is: get_rule, edit the returned document, validate_rule, then update_rule with it. Only name, description, category, icon and rules are editable; usage/bookkeeping fields are preserved server-side. A get_rule document already carries map_attribute_value search/replace in the correct {value:'<string>'}-objects form (paired by index) — edit those entries verbatim, never flatten them to plain strings (plain strings save but map nothing). update_rule keeps ruleId + every attachment, so the edit updates all attributes using this rule; the value/options mapping is not run by validate_rule's dry-run — verify after a real export/build. `scope` selects the library: 'project' (default) or 'shared_template' (a template_read_only error means your access cannot write there). Returns {ruleId, scope, status, changed, reason, validation}; status 'updated' / 'no_changes' on success, or 'rejected' with the validation errors when invalid (HTTP 200, nothing written). SAVE-ONLY: the edit reaches a feed's output only after export_feed on the feeds that use this rule. project_id is OPTIONAL (inferred for a single-project customer; project_id_required otherwise — then call list_projects).
    ConnectorOAuth
  • Reads one template, by default INCLUDING its build configuration - the same "build" shape riddle_get returns and riddle_builder_create accepts. This is how a template is ADAPTED rather than copied: edit the returned "build" (wording, questions, blocks) and build it with riddle_builder_create under the template's "type", passing this id as "templateId" so the new Riddle is still recorded as coming from it - and so it starts out on the template's whole preset, layout included, with your build config on top. The design comes along in "preset", which carries the preset settings and the palette; "preset.paletteValues" is included whenever that palette is not an unmodified built-in one, so a custom (or customized) palette rebuilds directly. On an unmodified built-in palette there is no "paletteValues" at all rather than a partial one: "preset.palette" names it in full (e.g. "Forest") and its colors/fonts come from riddle://reference/palette/built-in-palettes, matched by "name". Not changing anything? riddle_template_use is one call and copies the template whole. Returns {id, title, type, category, isPublic, isQuickCreate, blocksCount, image, icon, createdAt, riddle, build, nextBlockId, warnings}; a template whose content has no build-configuration equivalent comes back with an empty "build" and a warning saying so - use riddle_template_use for those.
    ConnectorNo auth
  • Reads one template, by default INCLUDING its build configuration - the same "build" shape riddle_get returns and riddle_builder_create accepts. This is how a template is ADAPTED rather than copied: edit the returned "build" (wording, questions, blocks) and build it with riddle_builder_create under the template's "type", passing this id as "templateId" so the new Riddle is still recorded as coming from it - and so it starts out on the template's whole preset, layout included, with your build config on top. The design comes along in "preset", which carries the preset settings and the palette; "preset.paletteValues" is included whenever that palette is not an unmodified built-in one, so a custom (or customized) palette rebuilds directly. On an unmodified built-in palette there is no "paletteValues" at all rather than a partial one: "preset.palette" names it in full (e.g. "Forest") and its colors/fonts come from riddle://reference/palette/built-in-palettes, matched by "name". Not changing anything? riddle_template_use is one call and copies the template whole. Returns {id, title, type, category, isPublic, isQuickCreate, blocksCount, image, icon, createdAt, riddle, build, nextBlockId, warnings}; a template whose content has no build-configuration equivalent comes back with an empty "build" and a warning saying so - use riddle_template_use for those.
    ConnectorNo auth
  • Read a web page's metadata without downloading any images. Returns JSON { url, finalUrl, title, description, siteName, canonical, lang, themeColor, author, generator, feeds, openGraph, twitter, icons, cached }, where `feeds` is an array of RSS/Atom URLs, `openGraph` and `twitter` are the complete tag sets as string maps, and any tag the page does not declare is simply omitted. `icons` is always an empty array here because icon resolution is switched off — call fetch_site_logo when the caller wants a logo, favicon or icon. `finalUrl` is the address after redirects (up to 3 hops are followed), which is how you resolve where a domain actually points. This is the fast, cheap counterpart to fetch_site_logo: one page fetch and no image work. It reads the served HTML only — it runs no JavaScript, so a client-rendered page may expose little, and it does not capture how the page looks (use screenshot_url for that). The crawler identifies itself as RaziMetadataBot, and HTTP status is not checked, so a 404 or bot-challenge page that serves HTML is parsed as though it were the page you asked for. Errors: 400 for a URL that is refused as unsafe, redirects too many times, does not return HTML, or exceeds the 5MB page cap; 504 if the page does not answer within 10 seconds; 502 otherwise. Results are cached for 24 hours and replayed with cached: true; 20 calls per minute per IP, then 429.
    ConnectorNo auth
  • Read a web page's metadata without downloading any images. Returns JSON { url, finalUrl, title, description, siteName, canonical, lang, themeColor, author, generator, feeds, openGraph, twitter, icons, cached }, where `feeds` is an array of RSS/Atom URLs, `openGraph` and `twitter` are the complete tag sets as string maps, and any tag the page does not declare is simply omitted. `icons` is always an empty array here because icon resolution is switched off — call fetch_site_logo when the caller wants a logo, favicon or icon. `finalUrl` is the address after redirects (up to 3 hops are followed), which is how you resolve where a domain actually points. This is the fast, cheap counterpart to fetch_site_logo: one page fetch and no image work. It reads the served HTML only — it runs no JavaScript, so a client-rendered page may expose little, and it does not capture how the page looks (use screenshot_url for that). The crawler identifies itself as RaziMetadataBot, and HTTP status is not checked, so a 404 or bot-challenge page that serves HTML is parsed as though it were the page you asked for. Errors: 400 for a URL that is refused as unsafe, redirects too many times, does not return HTML, or exceeds the 5MB page cap; 504 if the page does not answer within 10 seconds; 502 otherwise. Results are cached for 24 hours and replayed with cached: true; 20 calls per minute per IP, then 429.
    ConnectorNo auth
  • Plan an A→B passage. Compare departure windows by default; pin a single departure only when the user gives an explicit time. ## Tool routing: read this first Before calling, classify the user's question: 1. **Pure weather lookup at a point** ("y aura-t-il du vent à Cassis samedi à 14h ?", "quelles vagues dimanche au cap Sicié ?"): call ``get_marine_forecast`` and answer in text. Do NOT call ``plan_passage``: there's no route to plan. 2. **Trajet question with a flexible date** ("Marseille → Porquerolles ce week-end", "demain ou après-demain", "dans les prochains jours"): call ``plan_passage`` in **compare-windows mode**, passing ``latest_departure`` (e.g. earliest+48h) and ``sweep_interval_hours`` (3 or 6 typically) so the user sees several departure scenarios side-by-side. Then pick 2-3 good ones and let the user choose. This is the **default** for trajet planning: same API cost as a single passage thanks to cache prewarm, much more value. 3. **Trajet with a precise hour pinned by the user** ("je pars demain à 8h", "départ Saturday 9am"): call ``plan_passage`` in single mode (no ``latest_departure``). Used for the final "show me the detailed plan for THIS departure" view, often after step 2. 4. **Methodology question** ("comment c'est calculé ?", "quelle efficacité par défaut ?"): call ``read_me``. Rule of thumb: if the user does NOT give an exact hour, prefer compare-windows. The widget renders one of the windows by default and the chat lets the user pick another. ## Waypoints must stay in the water This server does no land check. It samples wind and sea along the polyline you pass, then reports distance, ETA and complexity for that polyline, whatever it crosses. A leg drawn through a peninsula raises no error: it returns a passage that is too short, too fast, and scored on conditions the boat would never meet. So the route is yours to draw. Between every consecutive pair of waypoints the straight line must stay at sea. Add intermediate waypoints to round anything the direct line would cut: headlands, peninsulas, islands, shoals. - Toulon to Saint-Tropez: the direct line crosses the Massif des Maures. Pass south of the presqu'île de Giens, then round cap Bénat and cap Camarat before turning north into the gulf. - Brest to Douarnenez: the direct line crosses the presqu'île de Crozon. Exit the goulet, round the cap de la Chèvre, then head east into the bay. Keep about 1 NM of clearance off headlands, more with onshore wind or swell, and do not shave the inside of islands. Extra waypoints are close to free: the cap is 50, and sampling cost follows ``segment_length_nm`` and total distance, not the waypoint count. When in doubt, add the waypoint. A waypoint that lands ashore has a second effect. Open-Meteo returns no sea state over land, so those samples carry a null wave height and the complexity score silently falls back to wind only, dropping the axis that would have flagged a rough passage. Name the capes you routed around in your reply ("passage au large du cap Bénat"), so the user can correct a leg you drew wrong. ## Returned payload Single mode: - ``passage``: per-segment timing report (distance_nm, duration_h, model used, segments[] with TWS/TWA/boat_speed/Hs, warnings). - ``complexity``: 1-5 difficulty score with wind/sea breakdown and a human-readable rationale. - ``openwind_url``: deep-link to ohmywind.fr/plan that renders the same passage in the standalone web app. - ``disclaimer``: usage warning to relay (see below). Compare-windows mode (``latest_departure`` set): - ``mode``: ``"multi_window"``. - ``sweep``: ``earliest`` / ``latest`` / ``interval_hours`` / ``window_count``. - ``windows[]``: each entry has ``departure``, ``arrival``, ``duration_h``, ``distance_nm``, ``complexity`` (level + label + rationale), ``conditions_summary`` (tws_min/max, predominant sail angle, hs_min/max), ``warnings``, ``passage`` (full per-segment report), ``complexity_full`` (full score), ``openwind_url``. - ``meta_warnings``: top-level notes ("3 fenêtres ignorées …"). - ``disclaimer``: usage warning to relay (see below). ## ALWAYS relay the disclaimer This tool returns an ETA and a difficulty score the user may act on to decide whether to put to sea. Carry the ``disclaimer`` field into your reply, once, in the user's language, phrased naturally rather than quoted verbatim. Put it after the numbers, not before: it qualifies them, it does not replace them. Do not drop it because the plan looks easy, and do not repeat it on every follow-up turn about the same passage. ## How it renders On hosts that support MCP Apps (Claude, Claude Desktop, ChatGPT, VS Code Copilot, Goose, Postman, MCPJam), the response is automatically accompanied by an interactive widget: the live ohmywind.fr/plan view served via the ``ui://openwind/plan-passage`` resource declared on this tool's ``_meta``. The widget reads ``openwind_url`` from the structured output and embeds the matching plan view as an iframe. On hosts without MCP Apps support (Cursor, Le Chat, terminal), present a short text summary of the result (route, ETA, complexity, warnings) and offer ``openwind_url`` as the "View full plan →" link. ## ALWAYS include the openwind_url(s) in your text reply Even when the widget renders inline, the user wants the link spelled out so they can open the full app, share it, or bookmark it. Treat this as a hard requirement, not a fallback: - **Single mode**: end your reply with a Markdown link built from the ``openwind_url`` field, e.g. ``[Voir le plan détaillé →](<openwind_url>)``. Always use that value verbatim, never a URL you compose yourself: it points at the environment this server is configured for, which is not always the production site. - **Compare-windows mode**: list 2-4 of the most relevant windows and give each its own link, e.g. ``- Sam 2 mai 09h · 11h12 · ⚡2/5 · [voir →](url)``. The user picks one from the chat, not the widget. Phrase the link with intent ("voir le plan détaillé", "ouvrir cette fenêtre dans l'app"), not just a bare URL: the user should know what clicking does. ## Args waypoints: list of ``{"lat": ..., "lon": ...}`` dicts, 2 to 50. Used exactly as drawn. Read "Waypoints must stay in the water" above before building it. departure: ISO-8601 datetime, timezone-aware. archetype: one of ``list_boat_archetypes()`` names. efficiency: multiplier on polar speed. ``0.85`` racing, ``0.75`` cruising (default), ``0.65`` loaded family cruising, ``0.55`` heavy seas / fouled hull. segment_length_nm: target sub-segment length. Default 10 nm balances precision vs Open-Meteo budget; drop to 5 for tight coastal work, raise to 20 for long offshore legs. model: wind model. Default ``"auto"`` tries AROME (≤48 h) → ICON-EU (≤5 d) → ECMWF IFS 0.25° (≤10 d) → GFS (≤16 d). Pass an explicit name to bypass. max_hs_m: optional max significant wave height (meters) over the route: pass it if you have a sea-state estimate from ``get_marine_forecast`` and want it factored into the score. Defaults to wind-only scoring. motor_threshold_kn: optional sail-speed floor (knots) under which the simulator switches to engine power. Must be paired with ``motor_speed_kn`` (either alone is ignored). Typical value 2 kn: sailors fire up the engine rather than crawl in light wind. Leave unset for 100% sail. Range (0, 10]. motor_speed_kn: optional speed under engine (knots) applied to segments where the sail estimate falls under ``motor_threshold_kn``. Typical 5-6 kn for a cruising boat. Range (0, 12]. min_upwind_twa_deg: optional minimum sailable TWA (degrees) overriding the archetype's own value (42-50 deg depending on the boat). Pass it when you know the boat points better or worse than the archetype suggests. Range [25, 70]. ## Compare-windows mode (latest_departure set) When ``latest_departure`` is provided, the tool switches into a window-comparison call: it walks departure times from ``departure`` up to ``latest_departure`` every ``sweep_interval_hours`` (default 1 h). Returns ``{"mode": "multi_window", "sweep": {...}, "windows": [...]}`` instead of the single-passage payload. Each window contains ``departure``, ``arrival``, ``duration_h``, ``distance_nm``, ``complexity``, ``conditions_summary``, ``warnings``, and its own ``openwind_url``. ``target_eta``: optional ISO-8601 datetime. When set, only windows that arrive within ±2 h of the target are returned. If none match, all windows are returned with a ``meta_warnings`` note. ## Failure modes Raises ``ForecastHorizonError`` if the chosen model's horizon doesn't cover the passage and ``model != "auto"``. The error message names the failing model and suggests longer-range alternatives.
    ConnectorNo auth
  • Generate a cohesive SET of custom images with TRANSPARENT backgrounds, each one a separate isolated subject sharing one visual style (icons, logos, sprites, UI assets that need to drop onto any backdrop). The style parameter says how everything is drawn; the subjects parameter says what to draw. The style can also come from reference images via the styleReferences parameter - alone, or best combined with the style text (text plus references holds a style tightest), so an existing set can be extended in its original style across many calls. Returns a zip download URL. Each call costs 1 credit. When a solid colored background fits the user's use case, generate_image_set (1 credit per call) is the faster choice. Run generation calls sequentially, never in parallel - only one generation runs at a time per API key. Output formats: PNG (lossless) or WebP. JPG is not supported because it has no alpha channel. Size and quality considerations match generate_image_set: leaving width and height unset delivers native resolution (best quality, varies between generations); fixing them resamples to that box, and fixing one axis lets the other hug each subject. IMPORTANT - style and subject description rules for best results: The style applies to every image in the set, so it is what keeps them visually consistent. Put HOW the images are drawn (technique, palette, surface treatment) in the style, and make each subject description only about WHAT that one subject is, not how it looks. A quick test for any phrase: is it WHAT the subject is, or HOW it is drawn? HOW belongs in the style, shared across the set. - Get the style and the subject descriptions right with the user before you call. When their request puts how an image is drawn, a background, or a scene into a subject description (or names the subjects to draw in the style rather than as separate entries in the subjects list), fix it as you compose the call: routine moves of shared technique into the style you can just make, but when a change drops or alters something they explicitly asked for, tell them what you are adjusting and why first. Each call costs a credit, so it is worth getting this right up front rather than spending one on a framed or scene-filled result. - The style describes the visual treatment of the images (e.g. 'watercolor', 'pixel art', 'stained glass'). It must NOT mention background color, image count, layout, or sizing. - Do not list the subjects to draw in the style (e.g. 'illustrations of a fox, an owl, and a deer'); the style is only the shared visual treatment, and the subjects belong in the subjects list, one per entry. A category or theme word is fine (e.g. 'insect illustration'). - Do not put background color or background descriptions in the style or subject descriptions. - Avoid framing the style as a type of painted canvas ('oil painting', 'acrylic painting', 'gouache painting', 'pastel painting'). These tend to produce each image as a rectangular framed canvas with its own colored background, rather than an isolated subject. Prefer 'illustration' or a specific technique: 'watercolor illustration', 'pen-and-ink sketch', 'ink wash', 'relief-etching', 'pastel drawing', 'woodblock print'. - Avoid color-field or atmospheric phrasings in the style ('luminous backgrounds of violet, rose, and gold', 'set against jewel-tone fields', 'dreamlike rainbow atmosphere'). These instruct the image model to fill each image with colored atmosphere, producing framed compositions rather than isolated subjects. Describe only the linework, palette, and technique of the subjects themselves. - Do not describe an aged, weathered, cracked, or textured surface, ground, wall, panel, or paper that the whole artwork sits on ('on aged wood', 'cracked fresco wall', 'aged parchment surface'); name the art tradition(s) or style(s) instead ('fresco-style illustration'). Texture that belongs to a subject's own material is fine ('a weathered bronze shield', 'a cracked ceramic vase'). - No captions, labels, or annotations. Text that is part of the depicted object is fine (e.g. 'STOP' on a stop sign, 'EXIT' on an exit sign). - No grid lines, borders, frames, or separators. - No overlapping or collage-style arrangements. - Do not connect the subjects to each other or give them shared physical elements: no wires, cords, chains, ropes, ribbons, vines, or threads running between subjects, no frame or banner they share, no phrasing like 'connected by' or 'strung together', and no single continuous line or tube forming multiple subjects. Each subject must be drawable in complete isolation; connections inside one subject (a chain on an amulet, laces on a boot) are fine. - No dramatic/long drop shadows (subtle shadows are fine). - Image descriptions should describe WHAT to depict, not where to position it. - Each image is ONE isolated subject, not a scene. Describe the subject with its pose or action and anything it directly holds, rides, or interacts with, but not the surrounding setting, environment, landscape, or sky. For a single composed scene (a figure set within an environment), use generate_illustration instead. - Do not use size words (large, tiny, small, etc.) on the overall image subject (e.g. 'a large elephant', 'a tiny mouse') - all images are produced at the same size. Size words on details within the image are fine (e.g. 'a plate with a small insignia'). - Maximum 18 images per generation. Do not put the image count in the style. - Subjects must be distinct: entries that differ only in case, punctuation, or spacing count as the same subject and the call is rejected. Explicit filenames must be distinct too (a different extension alone is not distinct). - The style must actually describe a visual style, and each subject must name a drawable subject; text that does not is rejected. - Style description max length: 500 characters. Image description max length: 200 characters each. - Size: width and height are separate parameters, each 256 to 512 pixels when given. Both given is an exact box; one given fixes that axis and the other hugs each subject (so images in the set differ on it, and it may fall below 256); neither given delivers native resolution, which is also the path to larger images. - Sizing: relative (the default) keeps the sizes the model gave the subjects in relation to one another, one scale for the whole set; fill scales each subject on its own to fill its frame less the margin, the icon-set convention, giving up relative size and enlarging subjects smaller than the frame (the result says by how much). Both can be changed later with edit_image_set. - Icons: the subject count sets how large a batch's icons can later be exported with export_icons, crisp at every density: about a 136px base size with 13 to 18 subjects, 160 with 10 to 12, 180 with 7 to 9, 192 with 5 or 6, 256 with 4 or fewer. Every generation result states its batch's own crisp base size. - If the style check returns a suggested cleanup, show the user the specific changes and get their confirmation, then resubmit the approved prompt with validation set to "skip" so it generates exactly as approved (resubmitting without "skip" re-runs the check and may return further suggestions). See the validation parameter for when to use "skip" and "auto-apply". - If a "Rate limit exceeded" error is returned, wait the suggested number of seconds before retrying. Do not retry immediately.
    ConnectorAPI key
  • Lists Riddle's public templates - the ready-made ones every account has, as opposed to riddle_template_list's own ones. They are grouped by category (the tag the Creator sorts them by), so calling this without arguments is also how you learn which categories exist; "category" and "type" narrow it. Returns {categories: {<category>: [{id, title, type, blocksCount, image, icon, createdAt, riddle, isPublic}]}, total} - the one listing here that is grouped rather than a flat "items" - and without the build configuration, which is riddle_template_get (or hand the id straight to riddle_template_use).
    ConnectorNo auth
  • Lists Riddle's public templates - the ready-made ones every account has, as opposed to riddle_template_list's own ones. They are grouped by category (the tag the Creator sorts them by), so calling this without arguments is also how you learn which categories exist; "category" and "type" narrow it. Returns {categories: {<category>: [{id, title, type, blocksCount, image, icon, createdAt, riddle, isPublic}]}, total} - the one listing here that is grouped rather than a flat "items" - and without the build configuration, which is riddle_template_get (or hand the id straight to riddle_template_use).
    ConnectorNo auth
  • Show an inline card of transcoding jobs from this conversation. Renders a compact jobs list (MCP Apps UI widget) with status badges, All/Active/Done/Errors filters, expandable rows, and output URLs. Use this when the user asks to see their jobs, a jobs dashboard, the status of several jobs at once, or after you just submitted a job — ALWAYS call this in the same reply as `transcode_video` / `start_encode2_raw`. Prefer it over dumping raw `get_job_status` JSON or looping status yourself. While any listed job is still in flight the card refreshes itself. If a row is already Done with a playable URL (mp4 / webm / HLS / DASH), follow with `open_player`. If the deliverable is a json/txt/srt/vtt file, follow with `fetch_job_result` and give the user the URL plus the extracted content. There is NO account-wide job history. Pass `task_tokens` from this conversation (the `task_token` returned by `transcode_video` / `start_encode2_raw`, or tokens the user pasted). Do not invent tokens and do not call `create_bucket` to "find" jobs. Clicking a job ID (or the copy icon) copies the token. A playable output URL (mp4 / webm / HLS / DASH) should go to `open_player`. Args: task_tokens: job IDs to show, most recent first. Capped at 20. When the result carries a non-null `next`, follow it in the same reply (`open_player` and/or `fetch_job_result`) and tell the user about the inline player or the extracted file content. `next` is set only when a listed job is already Done with a matching output. When the result carries a non-null `client_note`, pass its point on to the user in the same reply (hosts that collapse the widget until expanded).
    ConnectorOAuth
  • Update a Page — rename, set icon, replace the body, or archive/unarchive (archived:true hides it, false restores it). `body` is plain text (blank lines → paragraphs) and REPLACES the page content. Omitted fields are unchanged. Resolve the id via list_pages; only id is required.
    ConnectorNo auth
  • Get a ready-made AI-generated icon pack (12 consistent icons) — e.g. a house style like 'clay-starter' / 'line-minimal-starter', or a pack generated in the MEASURED style of a decoded brand. Free and unmetered. Each image is a 1024px transparent PNG you can download and use directly (full commercial rights). Unknown slug → lists available packs.
    ConnectorNo auth
  • Get a multi-day weather forecast for any Swiss location. Returns daily summaries (temperature, precipitation, sunshine, wind, weather icon) plus a hierarchical hourly breakdown of every series. This uses official MeteoSwiss Open Data — the same forecasts powering the MeteoSwiss app and website. Accepts: - Postal codes: "8001" (Zurich), "3000" (Bern), "1200" (Geneva) - Station abbreviations: "SMA" (Zurich Fluntern), "BER" (Bern) - Place names: "Zurich", "Basel", "Lugano" Coverage: ~6000 Swiss locations (all postal codes + weather stations + mountain points). Forecast horizon: up to 9 days. Updated hourly. Each day's summary fields: temperature_min_c, temperature_max_c, precipitation_total_mm, sunshine_total_minutes, wind_avg_kmh, wind_gust_max_kmh, weather, weather_icon_url. Each day also includes "hourly": one array of per-hour objects covering every series together — { time, temperature_c, precip_mm, sunshine_minutes, wind_kmh, wind_gust_kmh } — useful for judging *when* rain, sun, or wind is expected, not just the daily summary: - Each entry's "time" is already local wall-clock time for the location (Europe/Zurich), with the UTC offset included, e.g. "2026-07-09T14:00:00+02:00". It is NOT UTC — do not convert it. - A dry/calm/sunless hour is reported as its measured value (often 0), not omitted. A fully dry day is still a full array of zero-precipitation hours, not an empty array. - Each field is independently null if just THAT series has no reading for a given hour — the other fields for that same hour are still populated. An hour is omitted entirely only when every series is missing for it. - "hourly" itself is null when no hourly breakdown exists for this location at all (a total data gap); [] only when this location supports hourly data but none was available for that specific day. - For weather stations, temperature_min_c/temperature_max_c/precipitation_total_mm are MeteoSwiss's own official daily aggregates — a different, separately-curated product from the hourly series shown alongside them. They can legitimately NOT match summing/ averaging the hourly entries for that day; this is expected, not a data error. sunshine_total_minutes/wind_avg_kmh/wind_gust_max_kmh have no official daily product for stations and are always derived from the hourly series. For postal codes/mountain points, every summary field is derived from the same hourly series shown alongside it, so it always matches summing/averaging that series exactly.
    ConnectorNo auth