Su sistema de diseño necesita un servidor MCP
Una de las mejores inversiones que puede hacer para su sistema de diseño en este momento es un servidor Model Context Protocol (MCP). A medida que los modelos de IA evolucionan, se vuelven cada vez más capaces, pero su uso eficaz tiene un costo. Cada ficha que una IA desperdicia adivinando cómo funcionan sus componentes es dinero que queda sobre la mesa. Un servidor MCP le brinda a la IA un conjunto de herramientas que puede usar para buscar exactamente cómo usar su sistema de diseño. Piense en ello como una API a la que una IA puede llamar en lugar de adivinar. En este artículo hablaremos sobre por qué esto es importante y cómo puedes comenzar con el tuyo propio.

Antes de entrar en materia, hay algunas cosas sobre el uso de la IA que vale la pena abordar. He tenido una buena cantidad de escepticismo en el pasado, pero los recientes lanzamientos de modelos han hecho que sea cada vez más difícil argumentar que la IA no es una herramienta viable para la mayoría de los flujos de trabajo, incluida la creación de interfaces de usuario. La mayoría de los modelos de lenguaje grandes se entrenan con datos públicos extraídos de Internet, lo que significa que su sistema de diseño interno es en gran medida invisible para ellos, especialmente si su documentación se encuentra detrás de una red corporativa. Sin un MCP, un agente de IA en cualquier herramienta de codificación agente como GitHub Copilot o Claude seguirá intentando usar su sistema, a menudo husmeando en su node_modules carpeta, llenando los espacios con su mejor suposición. De ahí provienen las API de componentes alucinados. Un servidor MCP no sólo hace que la IA sea más útil para su sistema de diseño, sino que aborda directamente el problema de confianza al reemplazar las conjeturas con un contexto estructurado y preciso.
Al final del día, los usuarios de un sistema de diseño quieren una interfaz de usuario que cumpla con las pautas de la marca lo más rápido posible. Entonces, ¿por qué no capacitarlos para que utilicen la IA de forma más eficaz dándoles a sus agentes un libro de recetas para su sistema? Es beneficioso para todos: obtienen un diseño que utiliza los componentes y tokens de diseño correctos desde el principio, y usted obtiene una mayor adopción sin la participación habitual. Un servidor MCP lo hace posible al brindarles a los agentes de IA herramientas concretas para resolver esas preguntas, producir muestras de código y diseñar el uso de tokens que realmente reflejen su intención en lugar de una suposición fundamentada.
Creando un servidor MCP#
Comenzar a utilizar un servidor MCP es más sencillo de lo que cabría esperar. En lugar de puntos finales, un servidor MCP expone “herramientas” que una IA puede invocar por su nombre cuando necesita información. La diferencia clave con una API tradicional es que no es necesario que la respuesta se ajuste a un esquema estricto. A diferencia de una API REST donde un cliente falla si la forma de los datos cambia, una herramienta MCP puede devolver texto estructurado libremente o JSON y la IA le dará sentido. Su trabajo es simplemente señalarle la información correcta.

Si estás usando Node, puedes usar el paquete @modelcontextprotocol/sdk para comenzar:
servidor.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const server = new McpServer({
name: "my-design-system",
version: "1.0.0",
});
const transport = new StdioServerTransport();
await server.connect(transport);
Para un sistema de diseño, querrás considerar exponer herramientas en este sentido:
- Listar componentes: le da a la IA un índice de todo lo disponible para que sepa qué buscar antes de escribir una sola línea de código.
- Obtener componente: devuelve los detalles completos de un componente específico: accesorios, espacios, eventos y cualquier restricción de uso. Aquí es donde se eliminan las API alucinadas.
- Lista de documentación: permite a la IA descubrir qué orientación escrita existe, lo que resulta útil para preguntas más amplias sobre patrones y composición a nivel de página.
- Obtener documentación: recupera el contenido real de una página de documento, incluida la orientación obstinada y los casos extremos que los tipos de accesorios por sí solos no pueden transmitir.
- Obtener ejemplos de componentes: extrae historias reales de Storybook para que la IA vea patrones de uso funcionales en lugar de inferirlos de la firma del componente.
Esto le da a la IA la capacidad de consultar todo su sistema de diseño y profundizar en detalles de componentes específicos según sea necesario. La forma de crear estas herramientas dependerá de su configuración existente. Si está creando principalmente componentes web, puede conectarse directamente a su manifiesto de elementos personalizados, que ya incluye todos sus componentes y sus opciones en un formato legible por máquina:
servidor.ts
import fs from "fs";
import { z } from "zod";
interface CustomElementDeclaration {
kind: string;
name: string;
tagName?: string;
summary?: string;
customElement?: boolean;
members?: Array{ kind: string; name: string; type?: { text: string }; description?: string }>;
slots?: Array{ name: string; description?: string }>;
events?: Array{ name: string; description?: string }>;
}
interface CustomElementsManifest {
modules: Array{
declarations?: CustomElementDeclaration();
}>;
}
const manifest: CustomElementsManifest = JSON.parse(
fs.readFileSync("./custom-elements.json", "utf-8")
);
const getDeclarations = (): CustomElementDeclaration() =>
manifest.modules.flatMap((m) => m.declarations ?? ());
server.tool(
"list-components",
"Lists all available components in the design system",
{},
async () => {
const components = getDeclarations()
.filter((d) => d.kind === "class" && d.customElement)
.map((d) => ({ name: d.name, tagName: d.tagName, summary: d.summary }));
return {
content: ({ type: "text", text: JSON.stringify(components, null, 2) }),
};
}
);
server.tool(
"get-component",
"Gets the full details of a component including its properties, slots, and events",
{ name: z.string().describe("The component class name or tag name") },
async ({ name }) => {
const component = getDeclarations().find(
(d) => d.name === name || d.tagName === name
);
if (!component) {
return {
content: ({ type: "text", text: `Component "${name}" not found.` }),
};
}
return {
content: ({ type: "text", text: JSON.stringify(component, null, 2) }),
};
}
);
Si está utilizando Storybook, puede recorrer el árbol de sintaxis abstracta para volver a ensamblar historias como ejemplos consultables. Escribí sobre esto en otro artículo en el contexto de la validación del renderizado del lado del servidor, pero aquí se aplican los mismos principios. Alternativamente, puede usar el complemento del servidor Storybook MCP para exponer sus historias como herramientas sin necesidad de escribir ningún código personalizado si está usando un idioma que admita.
servidor.ts
import ts from "typescript";
import fs from "fs";
import path from "path";
import { glob } from "glob";
interface Story {
name: string;
source: string;
}
function extractStories(filePath: string): Story() {
const code = fs.readFileSync(filePath, "utf-8");
const sourceFile = ts.createSourceFile(
filePath,
code,
ts.ScriptTarget.Latest,
true
);
const stories: Story() = ();
ts.forEachChild(sourceFile, (node) => {
if (
ts.isExportDeclaration(node) ||
(ts.isVariableStatement(node) &&
node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword))
) {
if (ts.isVariableStatement(node)) {
for (const decl of node.declarationList.declarations) {
if (decl.initializer && ts.isObjectLiteralExpression(decl.initializer)) {
stories.push({
name: decl.name.getText(sourceFile),
source: decl.initializer.getText(sourceFile),
});
}
}
}
}
});
return stories;
}
server.tool(
"get-component-examples",
"Gets Storybook usage examples for a given component",
{ name: z.string().describe("The component name to find stories for") },
async ({ name }) => {
const files = await glob(`**/${name}.stories.{ts,tsx}`, {
ignore: "node_modules/**",
});
if (!files.length) {
return {
content: ({ type: "text", text: `No stories found for "${name}".` }),
};
}
const stories = extractStories(files(0));
return {
content: ({ type: "text", text: JSON.stringify(stories, null, 2) }),
};
}
);
Cada vez más granular#
La mayoría de las herramientas de codificación agente pueden consumir su servidor, aunque el formato de configuración varía según cuál esté utilizando. Para VS Code, agregue un .vscode/mcp.json archivo y apúntelo a la dirección HTTP o a la ruta stdio:
.vscode/mcp.json
{
"servers": {
"my-design-system-mcp": {
"type": "http",
"url": "https://your-design-system.com/mcp"
},
"my-other-mcp": {
"command": "node",
"args": ("./mcp/server.js")
}
}
}
Una vez que tenga un servidor MCP en ejecución, su documentación se vuelve aún más importante ya que ahora la leen tanto humanos como agentes de IA. Esta es una buena oportunidad para ser específico. En lugar de documentar que un componente de botón acepta una variant prop, documente por qué se deben evitar ciertas combinaciones; por ejemplo, variant="ghost" tiene intencionalmente poco contraste y no debe usarse como llamado a la acción principal dentro de un formulario. Una IA sin ese contexto lo aprovechará de todos modos porque parece una opción válida. Lo mismo se aplica a las soluciones que se han difundido de boca en boca: si vive solo en la cabeza de alguien o en un hilo de Slack, una IA nunca la encontrará. Cuanto más centrada y obstinada sea su documentación, más centrada y obstinada será la producción de su IA. Las refactorizaciones que de otro modo llevarían semanas pueden, de manera realista, reducirse a días u horas si el contexto es sólido.
Si desea desbloquear aún más potencial, vale la pena invertir en emparejar su servidor MCP con Figma Code Connect. Figma tiene su propio servidor MCP que puede leer las especificaciones de diseño directamente. Dado que puede conectar varios servidores MCP a la vez, una IA puede tomar una especificación de diseño, identificar los componentes correctos para usar y luego consultar su sistema de diseño MCP para conocer los detalles de implementación y los casos extremos; todo lo que necesita son algunas habilidades de agente para que eso suceda. El resultado es un flujo de trabajo en el que la IA pasa del diseño al código con mucho menos ida y vuelta.
Conclusión#
Los equipos que aprovecharán al máximo las herramientas de IA son aquellos que les brindan el mejor contexto para trabajar. Un sistema de diseño bien mantenido con un servidor MCP es exactamente eso: una línea directa entre sus estándares y las herramientas que sus ingenieros utilizan todos los días. La abstracción y la coherencia que siempre han proporcionado los sistemas de diseño se vuelven significativamente más valiosas cuando la IA puede consumirlas de manera confiable. Esto también se aplica más allá de los sistemas de diseño: cualquier biblioteca bien documentada se beneficia del mismo enfoque.
Los sistemas de diseño siempre han consistido en brindar a los equipos un lenguaje compartido. El servidor MCP simplemente significa que la IA también puede hablarlo.
