landigo-mcp

Connect your own coding agent (Claude Code, Codex, Cursor, Gemini CLI, Qwen Code, Kimi CLI, opencode, Windsurf, Amp, Copilot CLI, Crush, Zed, Cline, ...) to your Landigo studio. Your agent does the designing; these tools feed it your brand and the Landigo skill pack, and deliver finished work back into the studio. No model API key: inference bills to your own agent account.

What you get

• Brand context in: get_brand_context, list_templates, the Landigo skill pack (list_skills / get_skill: clone, motion, shader, taste, landing).
• See your projects: list_documents lists what is open in the studio right now, your local design library (read from the open studio), and your published pages, with the exact docId to design into.
• Design live in the studio: request_design_tool { docId, tool } runs editor tools against that document (author with render_jsx / write_html, read with get_jsx / get_screenshot, tokens, Brand Extract). No attach needed; attach_design_chat is only for LISTENING to the user's chat messages.
• Take the design out: request_design_tool with get_jsx (code), export_node / get_screenshot (images), export_fig (a native .fig), get_publish_url (the live /p/<slug> link).
• Deliver a finished design: push_design { name, jsx } lands it in your document as editable frames in free canvas space, selected and framed, and returns the editor link (plus the /p/ link when that document is published). With the studio closed it waits in your inbox and shows up on the Landigo home as a card that opens a new document with the design already rendered.
• Legacy: push_landing drops a self-contained HTML page onto the old Landing pages canvas. Kept working; push_design is the one to use.

Setup

One command:

npx landigo-mcp install

It finds the coding agents on this machine and registers this server with each of them, in the format each one documents:

| Agent | Where it is written | |---|---| | Claude Code | claude mcp add --scope user, so every project has it | | Codex | codex mcp add, or the [mcp_servers.landigo] block in ~/.codex/config.toml | | Cursor | ~/.cursor/mcp.json | | Gemini CLI | ~/.gemini/settings.json | | Qwen Code | ~/.qwen/settings.json | | Kimi CLI | ~/.kimi/mcp.json | | opencode | ~/.config/opencode/opencode.json | | Windsurf | ~/.codeium/windsurf/mcp_config.json | | Amp | ~/.config/amp/settings.json | | GitHub Copilot CLI | ~/.copilot/mcp-config.json | | Crush | ~/.config/crush/crushrc | | Zed | settings.json (context_servers) | | Cline | ~/.cline/mcp.json |

Agents that are not on the machine are skipped, existing configuration is merged rather than rewritten, and one agent failing never stops the rest. It asks for nothing, writes no credentials, and prints what it did. --print shows what it would write without touching anything, --force re-registers over an existing entry, --all lists the agents it skipped. Running it twice changes nothing.

Then restart your agent and sign in:

say "connect to landigo"
or run /landigo:auth

Either one prints a link. Open it, press Approve, and that machine is signed in for good. Nothing to find, nothing to paste. From a plain terminal the same flow is npx landigo-mcp login.

Claude Code:

claude mcp add landigo --scope user -- npx -y landigo-mcp

Codex, in ~/.codex/config.toml:

[mcp_servers.landigo]
command = "npx"
args = ["-y", "landigo-mcp"]

Cursor, Windsurf, Claude Desktop and friends, in their mcp.json:

{
  "mcpServers": {
    "landigo": {
      "command": "npx",
      "args": ["-y", "landigo-mcp"]
    }
  }
}

On Windows use "command": "cmd", "args": ["/c", "npx", "-y", "landigo-mcp"] for the JSON and TOML forms: npx is a .cmd shim there and a launcher that spawns it without a shell cannot run it.

No environment variables in any of these, on purpose. LANDIGO_TOKEN and LANDIGO_URL are still read when they are set, but an empty one is ignored rather than saved over a good token.

Then start your agent and say show me my Landigo projects. It calls list_documents, you pick one, and it designs straight into it: no attach step, no reconnect ritual. Say attach to my design chat only when you want the agent to listen and answer in the studio's chat panel.

Connections survive weather: if the studio restarts or the network blinks, the server retries with backoff and reports a plain retryable error instead of dying, so the Landigo tools never vanish mid-session.

Get your designs out

Once you have designed something, take it out however you need it:

| You want | Ask the agent to run | | ----------------- | ---------------------------------------------------------- | | your project list | list_documents | | a finished design delivered | push_design | | the code (JSX) | request_design_tool get_jsx | | a picture | request_design_tool export_node (PNG/JPG/SVG) | | the Figma file | request_design_tool export_fig (a native .fig) | | a shareable link | Publish in the studio, then request_design_tool get_publish_url | | one component's source | get_component backgrounds/aurora (slugs are in the studio's Library) |

Publishing is a one-click, user-gated step in the studio (the Publish button); get_publish_url reads the resulting /p/<slug> URL, it never publishes for you.

Modes

npx -y landigo-mcp            # stdio MCP server (what every agent config spawns)
npx -y landigo-mcp install    # register this server with the agents on this machine
npx -y landigo-mcp login      # sign this machine in through the browser
npx -y landigo-mcp worker     # run studio chat jobs through YOUR local agent CLIs
npx -y landigo-mcp http       # remote streamable-HTTP MCP server (mcp.landigo.dev)
npx -y landigo-mcp component <category/name> [--dir ./src/components]
npx -y landigo-mcp background <id> [--params "speed=2"] [--dir ./src/backgrounds]
npx -y landigo-mcp texture [--recipe ./texture-recipe.json] [--dir ./src/textures]

login takes --url https://your-studio for a self hosted studio (remembered afterwards), --token lgo_... to skip the browser, and --fresh to sign in as somebody else.

Taking anything out of the studio without an agent

The library, the Background Studio and the Texture Lab all publish themselves as public static JSON, so these three modes need no token and no MCP client at all. Each writes real files into your project and prints the packages to install. The dependency line is printed rather than run, so your package manager and your lockfile stay your decision.

Add --prompt to any of them to print a complete handoff for your coding agent instead of writing anything: what the asset is, the command that fetches it, the files and where they go, the packages, and the parameters that were chosen.

A component

npx -y landigo-mcp component lab-buttons/3d-button --ts

3D Button (ts-default) -> ./src/components
  src/components/3d-button/3d-button.tsx
  src/components/3d-button/demo.tsx
  src/components/landigo/utils.ts

Install what it needs:
  npm i clsx tailwind-merge

The landigo/ file is not decoration. A large part of the collection imports shared helpers through an alias that resolves only inside the library's own project; those modules are written next to the component and the imports are rewritten to point at them, so what lands compiles. The install line is read from the code's own imports rather than from a published manifest, because a handful of components import packages their manifest never mentioned.

A background

Backgrounds are LIVE, so this writes code rather than a picture: the mount module, a React wrapper with your tuned values as its defaults, and the type contract. --params takes the Background Studio's own query encoding, so a tuned background copied out of the studio arrives tuned.

npx -y landigo-mcp background --list
npx -y landigo-mcp background ferrofluid --params "speed=1.4&flowDirection=up"

A texture

A texture is a stack of effects over a picture you supply, so its output is genuinely raster and there is no live component to hand over. What this writes is the renderer plus the recipe, which is more than an export: the same texture can be produced again at any size from the same source, rather than upscaled.

npx -y landigo-mcp texture --recipe ./texture-recipe.json

import { renderTexture } from './landigo-texture/render-texture'
import recipe from './landigo-texture/recipe.json'

const canvas = await renderTexture(recipe, sourceImageUrl, { scale: 2 })

Zero dependencies, Node >= 18. License: MIT.