4,500+ servers built on MCP Fusion
Vinkius

Storybook MCP. Inspect components and read design docs in your terminal.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Storybook MCP on Cursor AI Code Editor MCP Client Storybook MCP on Claude Desktop App MCP Integration Storybook MCP on OpenAI Agents SDK MCP Compatible Storybook MCP on Visual Studio Code MCP Extension Client Storybook MCP on GitHub Copilot AI Agent MCP Integration Storybook MCP on Google Gemini AI MCP Integration Storybook MCP on Lovable AI Development MCP Client Storybook MCP on Mistral AI Agents MCP Compatible Storybook MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Storybook MCP Server connects your AI client directly to a deployed Storybook instance. It lets you inspect every UI component, check prop signatures, map the entire design system structure, and retrieve implementation guidance—all from your terminal.

Stop context switching between documentation tabs and your code editor; get component data right where you're working.

What your AI agents can do

Extract docs guidance

Retrieves documented guidance and local source code paths for how a developer should implement a component.

Get preview url

Generates an isolated, temporary URL that lets you run and test a specific component's changes in a sandbox iframe.

Get story args

Retrieves the metadata, expected types, and default arguments for any given UI component.

+ 3 more capabilities included
Map the design system structure

Use list_categories and list_components to map out all available UI element folders and individual components.

Search for specific component metadata

Run search_components to find elements by name or keyword, followed by get_story_args to pull their props and default values.

Generate isolated visual previews

Create a temporary sandbox iframe endpoint using get_preview_url so you can test component variations live in the terminal.

Extract source code documentation paths

Use extract_docs_guidance to get local file paths and implementation notes for a component.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

Storybook MCP Server: 6 Tools for Component Inspection

Use these six tools to query your entire component library, find metadata, check prop signatures, and generate live previews without leaving your coding environment.

extract019d760d

extract docs guidance

Retrieves documented guidance and local source code paths for how a developer should implement a component.

get019d760d

get preview url

Generates an isolated, temporary URL that lets you run and test a specific component's changes in a sandbox iframe.

get019d760d

get story args

Retrieves the metadata, expected types, and default arguments for any given UI component.

list019d760d

list categories

Lists the top-level folder structure of your design system (e.g., Atoms, Molecules).

list019d760d

list components

Provides a comprehensive list of all individual UI components available in the Storybook.

search019d760d

search components

Searches for specific UI elements across the library using keywords or component names.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

  • Import from OpenAPI, Swagger, or YAML specs
  • Create Agent Skills with progressive disclosure
  • Deploy to edge with MCPFusion framework
  • Built in DLP, auth, and compliance on every call
  • Real time usage dashboard and cost metering
  • Publish to catalog or keep private
Start building

Make Your AI Do More

Start with Storybook, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ others, all in one place
  • Add new capabilities to your AI anytime you want
  • Every connection is secured and compliant automatically
  • Track usage and costs across all your servers
  • Works with Claude, ChatGPT, Cursor, and more
  • New servers added to the catalog every week

What you can do with this MCP connector

The Storybook MCP Server plugs your AI client straight into your component library. It lets you inspect every piece of UI code—the props, the structure, the docs—right from your terminal. You never gotta switch tabs or dig through local files to figure out how a component works; it's all right where you are.

Mapping Your Design System Structure

Need to know what components exist? First, run list_categories. This tool immediately spits out the top-level folder structure of your whole design system—you'll see things like 'Atoms,' 'Molecules,' or 'Templates.' You use list_components right after that; it provides a comprehensive list of every single component available inside those folders. If you want to find something specific, skip the browsing and run search_components.

This searches the whole library by keyword or component name so you can pinpoint what you need fast.

Deep Component Inspection

Once you've found a potential piece, you gotta know exactly how it works. Run get_story_args to pull up all the component’s metadata and default arguments. This tells you everything: which props it takes (e.g., label: string, isDisabled: boolean), what type they are, and if there's a default value set. It prevents you from guessing what parameters your code needs.

To figure out the implementation details, use extract_docs_guidance. This retrieves both the documented guidance for implementing the component and the local source code paths where that logic lives. That’s key—it gives you the exact file path you're looking for in your IDE.

Live Testing and Validation

Don't just read about it; test it. Use get_preview_url to generate an isolated, temporary sandbox iframe endpoint. This lets you run and check component variations live right in the terminal before you commit anything to your main build. It’s perfect for seeing how a change behaves without breaking local stuff.

You'll find that combining these tools gives you total visibility: map the structure with list_categories then narrow it down using search_components, check the required inputs with get_story_args, confirm where to put the code path via extract_docs_guidance, and finally, validate every change live using get_preview_url. It's everything you need in one place.

How Storybook MCP Works

  1. 1 You install the Storybook MCP module into your AI configuration. Then, you just need to provide the URL of your deployed Storybook instance.
  2. 2 The MCP natively reads your Storybook's static index.json file. This gives it a complete map of every component and its metadata.
  3. 3 Finally, you prompt your AI agent: "Search for 'Button', show me its props, and give me a preview URL." The agent then calls the right tools in sequence to get the answer.

The bottom line is that it turns your component library into an active data source your AI client can query like any other API.

Who Is Storybook MCP For?

Any developer who gets frustrated having to switch between their IDE, the Storybook UI, and documentation files. This is for the engineer tired of copy-pasting props from one tab to another, or the designer whose component requirements aren't clear because they can't programmatically validate the existing system.

Frontend Engineer

Using search_components and get_story_args to quickly verify if a required prop exists on an existing component before writing any code.

UI/UX Designer

Running list_categories to audit the entire design system structure, ensuring all new elements fit into defined components and tokens.

Technical Writer

Using extract_docs_guidance to automatically pull component documentation pathways, keeping your style guide updated without manual checks.

What Changes When You Connect

  • Find props instantly. Instead of guessing or checking the Storybook UI, call get_story_args to get component metadata and default arguments immediately. This prevents prop-related bugs.
  • Map the whole system. Use list_categories first, then list_components, to systematically audit your entire design system's folder structure from one prompt.
  • Avoid UI context switching. If you need a specific element, run search_components. You find it and get its metadata without opening any browser tabs.
  • Test changes safely. Need to see how a component looks before merging? get_preview_url creates an isolated iframe endpoint so you can preview it live in your terminal session.
  • Keep docs fresh. Use extract_docs_guidance to pull local source paths and documentation notes automatically, making technical writing easier and faster.

Real-World Use Cases

01

The engineer needs component props

You're building a new card layout. You remember there's a 'Badge' component but can't recall if it takes an isPremium boolean prop or just a string. Instead of guessing, you ask your agent to search_components for 'Badge,' and then run get_story_args. The agent returns the exact expected props list, letting you code right away.

02

The designer audits system consistency

A client asks you to prove that all buttons follow a consistent structure. You use the AI to first list_categories (to see if 'Buttons' is even defined), then run list_components to get every single component name, verifying structural adherence before any code touches it.

03

The technical writer updates documentation

A core component changes its internal structure. Instead of manually updating the README and finding the source paths, you ask your agent to extract_docs_guidance for that component. It pulls the resolved local path (./src/components/...) and any required import notes, saving hours of manual tracking.

04

Testing a visual change in isolation

You made a minor tweak to the primary button's padding locally. You don't want to rebuild the whole app just to check it. You ask your agent to generate a preview URL using get_preview_url, which gives you an isolated sandbox iframe ready for instant visual confirmation.

The Tradeoffs

Asking 'What components do we have?'

You just prompt: 'List all the UI parts.' This is too vague. The AI might get confused or give you a massive, unreadable dump of everything.

Start by mapping structure using list_categories. Then use list_components to filter down what you need. Always narrow your focus before asking for details.

Ignoring specific tool calls

You ask: 'Tell me about the button.' This general prompt forces the AI to guess whether you mean its props, its source path, or how it looks.

Be explicit. Say: 'Show me the component arguments for the Button' (using get_story_args) and then generate a preview URL for it using get_preview_url.'

Assuming context or state

You prompt: 'Check the button props.' If you haven't first told the AI which button, it won't know what to look up.

Always narrow down the target first. Use search_components to identify the exact component ID or name before calling tools like get_story_args.

When It Fits, When It Doesn't

Use this server if your primary job involves understanding, validating, or documenting a shared UI design system built in Storybook. If you're dealing with front-end components and their associated props/documentation, this is essential.

Don't use it if: 1) You are working on backend services (database calls, microservices). 2) Your goal is general code generation without referencing a specific design library. In those cases, you need a different kind of agent. The Storybook MCP Server only knows about the components deployed in your designated URL.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Storybook. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

How we secure it →

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This server provides 6 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

extract_docs_guidance get_preview_url get_story_args list_categories list_components search_components

Debugging component usage shouldn't require jumping between tabs and documentation files.

Right now, if you need to know the expected props for a custom dropdown, you usually have to open Storybook in one tab, check the docs on another, then switch back to your IDE to manually copy the prop names. It's tedious and you always risk missing a subtle default argument.

With this MCP server, you just ask the AI agent: 'What are the props for the Dropdown component?' The agent runs `get_story_args`, spits out the exact JSON schema with types (e.g., `{required: boolean, options: string[]}`), and keeps your workflow entirely within the terminal.

Storybook MCP Server: Inspect components & documentation

Before this server, generating a local source code path for a component meant manual browsing through the Storybook index and cross-referencing file structures. If the component was refactored, your docs would be wrong until someone manually updated the README.

Now, running `extract_docs_guidance` gives you the resolved file path (`./src/components/XYZ.tsx`) directly from the deployed index. This means your documentation stays synchronized with your actual codebase instantly.

Common Questions About Storybook MCP

How do I use `search_components` for a component? +

Just ask your agent to run search_components('keyword'). It will return a list of matching components and their full IDs, allowing you to know exactly what's available in the system.

Can I use `get_story_args` without knowing the component name? +

No. get_story_args needs a precise component identifier (e.g., 'Button/Primary'). You usually run search_components first to get that exact ID, then pass it to get_story_args.

How do I check if my Storybook setup is connected? +

You can test the connection by asking your agent to run list_components. If it returns a list of components, you're connected and working. If not, double-check that your STORYBOOK_URL is correct.

What if I want to see how the component looks live? +

Use get_preview_url. This tool generates an isolated sandbox iframe endpoint. You can then pass this URL to your agent for testing without affecting your local build or main app state.

What does `list_categories` show, and how do I use it to understand my design system's folder layout? +

It lists the top-level groupings (Atoms, Molecules, etc.). Run this first to map out your overall component architecture. This provides a necessary high-level view before you start querying specific components.

When using `list_components`, can I filter the results by a parent category or folder? +

Yes, you can optionally pass a category filter. This limits the component list output to just that section of your system. It’s perfect for auditing one specific module without getting overwhelmed by every component.

How does `extract_docs_guidance` work, and what format is the resulting source path? +

It resolves the local file paths directly from your Storybook index. The output gives you a clean, relative path (e.g., ./src/components/XYZ.tsx). You know exactly which folder to look in for the implementation logic.

If I search using `search_components`, can I get the arguments (`get_story_args`) for multiple results at once? +

The tool finds matches first. After you run search_components, you must then pass the resulting component IDs to get_story_args. It’s a two-step process: search, and then inspect each specific result.

Does it require API keys or OAuth? +

No. The MCP reads the static index.json file generated by your Storybook build. As long as the agent can reach the STORYBOOK_URL over the network, no additional authentication is needed.

Is the integration read-only? +

Yes. The AI reads component metadata, props, and documentation from the static index. It cannot modify actual React, Vue, or Angular source files through this integration.

Which UI frameworks are supported? +

Any framework supported by Storybook — React, Vue, Angular, Svelte, Web Components, and more. The MCP reads the universal index.json format, which is framework-agnostic.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 6 tools

We've already built the connector for Storybook. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 6 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.