An MCP server for UI design work.
Your coding agent can produce a working screen in a minute. What it cannot do on its own is know what a good one looks like. ThinkUI answers that from a library of real interfaces, over the Model Context Protocol — the same protocol your agent already uses for files and search.
Every agent ships the same screen.
Ask three different agents for a settings page and you get three versions of the same page: a heading, a card grid, a few toggles, generous padding. That is not a style. It is the median of the training data, reproduced confidently.
Design has always worked by looking at what other people solved. A designer opens five competitors before drawing anything. Your agent has no such habit: it has no way to check, so it guesses, and the guess is fluent enough that nobody notices until the interface is in front of a customer.
The fix is not a better prompt. It is giving the agent access to the evidence a designer would have used — what a checkout looks like when it is not hostile, how a dashboard frames an empty state, which typeface actually holds up in a dense table — and letting it cite what it used.
A reference library, exposed as tools.
ThinkUI is a hosted MCP server. Your agent connects to one URL, sends your key in a header, and gets five tools it can call mid-conversation.
| Tool | Answers | Returns |
|---|---|---|
| find_ui_references | How a screen, a flow or a pattern is actually designed | Screens and flows with the app they came from, the patterns they use and the components involved |
| find_ui_elements | What a component should look like | The component's own markup and stylesheet, ready to paste |
| find_animated_icons | Which animated icon fits an action | Working animated SVG, no runtime and no icon font |
| find_ui_materials | Which typeface, icon set or design system to use for a role | Candidates with their maintenance state and their source |
| corpus_stats | What the server actually holds | Counts by category, so an empty result is never a mystery |
The library behind the tools currently holds 1,639 references across 97 flows and 111 categories, plus MIT-licensed components, icons and materials. corpus_stats reports the live numbers, so your agent can check coverage before claiming something exists.
Ask for a decision, not a keyword.
The library is indexed by what a screen demonstrates. A topic word returns a category. A decision returns evidence.
Do this
"how a paywall frames its free trial"
"empty state for a search with no results"
"an onboarding checklist that does not nag"
Not this
"paywall"
"design system"
"make it modern"
The second column returns a category record or nothing. That is the server being honest, not broken.
How it differs from the Figma MCP server.
Both are MCP servers, both are about interfaces, and they answer opposite questions. Knowing which one you need is most of the decision.
| Figma MCP server | ThinkUI | |
|---|---|---|
| Source | The files in your own Figma account | Interfaces shipped by other products |
| Answers | "How is this frame built, and how do I code it?" | "How do good products solve this screen?" |
| Best moment | A design exists and needs to become code | No design exists yet, and the agent would otherwise guess |
| Sees competitors | No | Yes — that is the whole library |
| Writes to a canvas | Yes, on paid plans with a Full seat | No. It returns evidence, not edits |
| Assets | Your components and variables | MIT components, icons and materials; screenshots under their own licences |
Most teams should run both. Figma is the source of truth for what you have already decided; ThinkUI is the outside evidence for what you have not. If you want the longer version, it has its own page: ThinkUI as a Figma MCP alternative.
One URL, one header.
There is no package to install and no daemon to keep alive. Your key comes from your account page after you sign up.
claude mcp add --transport http thinkui \
https://thinkui.xyz/mcp \
--header "Authorization: Bearer your-key"
{
"mcpServers": {
"thinkui": {
"url": "https://thinkui.xyz/mcp",
"headers": { "Authorization": "Bearer your-key" }
}
}
}
Client-specific walkthroughs: Claude Code · Cursor · all clients.
What it will not do.
Draw the interface
It returns evidence and assets; your agent writes the code. ThinkUI is not a canvas and does not pretend to be one.
Grant rights it does not have
Screenshots keep their own licences. Where a screen is study-only, the result says do not ship or republish and names the owner.
Fill gaps with guesses
A query the corpus cannot answer comes back empty, with a note about what it does hold. That is the feature.
Questions this page gets.
What is an MCP server for UI design?
It is a Model Context Protocol server that gives a coding agent evidence about interfaces: real screens, the flows they belong to, the components they use, typefaces and animated icons. The agent calls it while it works, the same way it would call a search or a file tool.
Is this the same as the Figma MCP server?
No. The Figma MCP server reads the files in your own Figma account and turns them into code. A reference library like ThinkUI shows what other products shipped, so it answers a different question: what should this screen look like when nobody has drawn it yet. The two are complementary.
Do I need an MCP client to use it?
Yes. ThinkUI connects to any client that supports remote MCP servers over streamable HTTP, including Claude Code, Claude Desktop, Cursor, VS Code with Copilot, Windsurf, Zed and Codex. The server is hosted, so there is nothing to install locally.
What does a call actually return?
A result names the app and the flow a screen came from, what the screen demonstrates, the patterns it uses, the components involved and its licence. Where the corpus holds a screenshot it is attached; where the licence is study-only the result says so and forbids republishing.
Can my agent use the components commercially?
The components, animated icons and materials ThinkUI returns are MIT licensed. Screenshots are not: each keeps its own licence, and only the permissively licensed share may be shipped. Every result states which it is.
Does a query that finds nothing return an approximation?
No. An empty query returns an empty result and says what the library does hold. Approximating would turn an honest gap into an invented answer, which is the failure the server exists to prevent.
Stop the guess.
Connect the server, then ask a design question you already know the answer to. The difference is immediate.