What can you do with this server?

The BrandKit MCP server exposes a complete brand design system to AI tools via MCP, enabling structured retrieval, search, comparison, and validation of brand identity assets and guidelines. Verbal Identity * Retrieve brand positioning, audience, messaging, differentiation, creative concepts, and brand voice/tone documentation. * Access a human-authored taste primer (magic_trick.md) injected into creative tools. Visual Identity * Colors – Full palette with hex/RGB values, semantic roles, and usage guidelines; output as JSON, CSS, SCSS, Tailwind, or W3C Design Tokens. * Typography – Font families, sizes, weights, line heights, and usage guidelines per context. * Logos – Variants (primary, mark, wordmark, monochrome) with usage rules, clear space, minimum sizes, and optional base64 image data. * Components – UI component specs, variants, CSS properties, and usage guidelines, filterable by name, context, or category. * Design Tokens – Export in CSS custom properties, SCSS variables, Tailwind config, W3C Design Tokens, or JSON. * Textures & Patterns – Texture/pattern assets with usage context and optional base64 data. * Raw CSS – Raw CSS file contents and extracted custom property definitions. Cross-Cutting Tools * Full-Text Search – Search across all brand content: guidelines, component specs, color names, typography, and documentation. * Context-Specific Data – Query elements by context (base, web/marketing, product) with artifact overrides. * Context Diff – Compare design contexts (e.g., marketing vs. product) side-by-side, highlighting differences in colors, typography, and components. * Brand Compliance Validation – Validate specific color, font, or logo usages against brand guidelines, returning pass/fail with guidance. * Resource URIs – Access brand assets and documents directly via brand:// URIs across 18 tools and 14 MCP resources.

de en es ja ko ru zh

BrandKit MCP

by ejwhite7

Overview Schema Related Servers Score Discussions

TypeScript

Hybrid

BrandKit MCP

Give every AI tool access to your company's complete brand atomic system via the Model Context Protocol.

npm version License: MIT Node 20+ TypeScript ejwhite7/brandkit-mcp MCP server

BrandKit MCP v2 is an open-source MCP server that exposes a company's complete brand atomic system -- verbal identity (positioning, audience, messaging, differentiation, concepts, voice) and visual identity (colors, typography, components, tokens, motion, assets) -- to Claude and other AI tools via the Model Context Protocol (MCP). It ships 18 read-only tools, one local write tool, and 14 resources. When an LLM helps build a website, app, or marketing asset, it has instant structured access to the exact brand language and visual rules it needs -- including a human-authored taste primer that carries the brand's instincts, not just its specs.

Quick Start

# 1. Install
npm install -g brandkit-mcp

# 2. Scaffold a new brand atomic system from the starter template
brandkit-mcp init

# 3. Edit the scaffolded files with your brand content

# 4. Wire into Claude Desktop (or any MCP-compatible client)
#    Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
#    {
#      "mcpServers": {
#        "brandkit": {
#          "command": "brandkit-mcp",
#          "args": ["serve"]
#        }
#      }
#    }

init refuses to change an existing brandkit.config.yaml or brand_atomic_system/ unless --force is explicit. Force performs a clean replacement only for a regular single-link config and a real directory; symbolic links, hard-linked configs, and special-file destinations are rejected.

Related MCP server: guardrails-mcp-server

Repository Structure

A brand atomic system lives under a single <brand-root>/ directory (default: ./brand_atomic_system):

<brand-root>/
├── readme.md
├── magic_trick.md               # human-authored taste primer
├── brandkit.config.yaml         # version: 2
├── human/                       # PDFs and human-only material (MCP ignores)
│   └── *.pdf
└── agent/
    ├── verbal/
    │   ├── positioning.md
    │   ├── audience.yaml
    │   ├── messaging.md
    │   ├── differentiation.md
    │   ├── concepts.md
    │   └── voice.md
    └── visual/
        ├── colors_and_type.css
        ├── fonts/
        ├── assets/
        ├── components/
        ├── tokens/
        ├── motion/
        │   ├── motion.json
        │   └── motion.css
        └── artifacts/
            ├── web/             # override layer
            └── product/         # override layer

The human/ directory is intentionally ignored by the MCP server -- put PDFs, print specs, or any other human-only material there. Everything under agent/ is indexed and served.

MCP Tools Reference

BrandKit MCP exposes 18 tools to AI assistants:

Tool	Description
`get_brand_overview`	High-level overview + taste primer
`get_magic_trick`	Verbatim magic_trick.md
`get_positioning`	Positioning document
`get_audience`	Audience YAML, parsed
`get_messaging`	Messaging document
`get_differentiation`	Differentiation document
`get_concepts`	Creative concepts/directions
`get_voice`	Voice document
`get_colors_and_type`	Colors + typography custom properties
`get_assets`	Logos + brand assets
`get_fonts`	Font faces
`get_components`	UI primitives
`get_tokens`	Token specimens
`get_motion`	Motion system (json + css)
`get_css`	colors_and_type.css + motion.css text
`search_brand`	Full-text search
`validate_usage`	Validate brand compliance
`get_context_diff`	Diff base vs web vs product

The stdio transport also exposes sync_brand_docs, which updates brandkit.config.yaml, DESIGN.md, and PRODUCT.md. Network transports hide and refuse this write-capable tool by default.

Taste primer

Seven creative/verbal tools (get_brand_overview, get_positioning, get_audience, get_messaging, get_differentiation, get_concepts, get_voice) inject a _taste_primer field carrying magic_trick.md verbatim. get_magic_trick returns the primer directly without wrapping.

MCP Resources

BrandKit MCP exposes 14 brand:// URIs as MCP resources:

URI	Description
`brand://overview`	Brand overview
`brand://magic_trick`	Taste primer
`brand://verbal/positioning`	Positioning document
`brand://verbal/audience`	Audience YAML
`brand://verbal/messaging`	Messaging document
`brand://verbal/differentiation`	Differentiation document
`brand://verbal/concepts`	Creative concepts
`brand://verbal/voice`	Voice document
`brand://visual/colors_and_type`	Colors + typography CSS
`brand://visual/assets`	Asset index
`brand://visual/fonts`	Font face index
`brand://visual/components`	Component index
`brand://visual/tokens`	Token specimens
`brand://visual/motion`	Motion system

Configuration

The brandkit.config.yaml file at your project root controls BrandKit MCP:

version: 2
brand:
  name: Acme Corp
  description: Plumbing for builders.
  root: ./brand_atomic_system
contexts: [base, web, product]
ignore:
  - human/
ingestion:
  maxFileBytes: 16777216
  maxTotalBytes: 134217728
  maxFiles: 1000
  maxDepth: 16

Ignore entries are paths relative to brand.root. They match the named path and its descendants on directory boundaries, so human/ does not match humanity/.

Brand ingestion is bounded before file content is read. The defaults allow a maximum of 16 MiB per file, 128 MiB across all unique inputs, 1,000 unique files, and 16 path segments below brand.root. Fixed documents, discovered components and tokens, manifests, fonts, and image assets all share the same budget. Directory enumeration is also capped at four times the configured file limit, so a tree of empty or unsupported entries cannot create unbounded work before file counting. In-root symlink and hard-link aliases count once by canonical file identity; an alias cannot bypass containment or a limit. Exact boundaries are accepted and the next byte, file, or path segment fails startup with a brand-relative error. Large brands can raise these typed ingestion values up to the built-in safety caps (64 MiB per file, 512 MiB total, 10,000 files, and 64 segments); maxTotalBytes must be at least maxFileBytes.

version: 2 is required. A config file missing this field or declaring version: 1 causes the server to throw BrandkitV1ConfigError at startup.

Context System

BrandKit v2 supports three contexts:

Context	Purpose
`base`	Shared foundation -- fonts, core colors, global tokens
`web`	Overrides for the public-facing website (`agent/visual/artifacts/web/`)
`product`	Overrides for the SaaS application (`agent/visual/artifacts/product/`)

Verbal content (agent/verbal/) has no context overrides -- it applies globally. Visual content can be overridden per context via the artifacts/ layer.

Migrating from v1

2.0.0 is a breaking release. The directory layout, context vocabulary, and tool surface have all changed. No automated migration is included -- the path mapping is manual:

v1 path	v2 path
`brand/shared/colors/*.css`	`agent/visual/colors_and_type.css`
`brand/shared/typography/*.css`	`agent/visual/colors_and_type.css`
`brand/shared/logos/*`	`agent/visual/assets/`
`brand/shared/components/*.md`	`agent/visual/components/*.md`
`brand/shared/voice/brand-voice.md`	`agent/verbal/voice.md`
`brand/shared/guidelines/*.md`	`agent/verbal/{positioning,messaging,differentiation,concepts}.md`
`brand/marketing/*`	`agent/visual/artifacts/web/*`
`brand/product/*`	`agent/visual/artifacts/product/*`

Your brandkit.config.yaml must also be updated to declare version: 2 and use the new brand.root field. v1 configs throw BrandkitV1ConfigError at startup -- the server will not start until the config is updated.

Conventions

magic_trick.md is human-authored. The MCP reads it, but sync_brand_docs never writes to it. The taste primer is the brand's instincts -- it must stay human.

Token output formats. The get_tokens tool supports CSS custom properties, SCSS variables, Tailwind config, W3C Design Tokens, and flat JSON.

Brand files stay inside brand.root. Every fixed and discovered brand input is resolved and opened under the configured root. A symlink is accepted when its final target remains inside that root; symlinks and manifest paths that escape the root are ignored with a warning, and their content is never indexed or exposed through tools, resources, or preview pages.

The config must be a regular, single-link file. brandkit.config.yaml cannot be a symbolic link, hard link, directory, or other non-regular entry. The server binds config persistence to the file loaded at startup; if that path is replaced while the server is running, sync_brand_docs refuses to read or overwrite the replacement. Successful config updates use an atomic same-directory replacement and preserve existing permissions.

Transports. The server supports stdio (recommended for Claude Desktop), SSE (legacy HTTP), and Streamable HTTP (current MCP spec). Network transports remain unauthenticated when bound to loopback for local development. Before binding SSE or HTTP to any non-loopback host, set BRANDKIT_AUTH_TOKEN; clients must send it as Authorization: Bearer <token> on every request.

Network transports are read-only by default, including loopback, standalone, and Vercel deployments. To deliberately expose sync_brand_docs over SSE or Streamable HTTP, start the CLI with brandkit-mcp serve --transport http --allow-write-tools (or set allowWriteTools: true in the programmatic startServer options). Treat this as privileged mode: authentication is still mandatory for non-loopback binds. Stdio keeps the intended local write workflow without this flag. Adapters without a writable config context never advertise the tool, even if privileged mode is requested.

Every network transport rejects untrusted Host and Origin headers with HTTP 403. Loopback listeners automatically trust loopback hostnames and origins, including IPv4, IPv6, and ephemeral ports. A concrete non-loopback server.host derives trust for that exact hostname. Wildcard bindings (0.0.0.0 or ::) fail at startup unless server.allowedHosts is explicit:

server:
  transport: http
  host: 0.0.0.0
  port: 3001
  allowedHosts:
    - mcp.example.com       # hostname only; Host-header ports are ignored
  allowedOrigins:
    - https://app.example.com

allowedOrigins entries are exact HTTP(S) origins, including the port when it is non-default. If the list is empty, requests without an Origin header remain valid for MCP clients, while a supplied Origin must use a trusted Host hostname. Configure allowedOrigins explicitly when a browser application is hosted on a different origin. IPv6 entries in allowedHosts use brackets, for example [2001:db8::10].

The preview UI is deliberately loopback-only and refuses any wildcard, LAN, or public bind host. It also applies the same Host and Origin validation to every page and static asset. Use the authenticated MCP HTTP transport when data must be available beyond the local machine.

Docker Compose

The default Compose service runs the supported Streamable HTTP transport on http://127.0.0.1:3001/mcp. It uses the bundled Acme example, so a fresh checkout does not require host-side brand files. Set a bearer token before starting it:

export BRANDKIT_AUTH_TOKEN="$(node -e "process.stdout.write(require('crypto').randomBytes(32).toString('hex'))")"
docker compose up --build --wait --wait-timeout 60
npm run test:docker-smoke

The token is injected at runtime and is also required by the authenticated health check. Compose refuses to start when it is absent. To use your own brand, mount a regular config file and brand directory, set BRANDKIT_CONFIG to the container path of that config, and keep server.allowedHosts limited to the hostnames clients actually use. Do not put the token in the image or config file. Compose intentionally exposes only the authenticated MCP service; run the preview CLI separately on a trusted local machine. Existing stdio container integrations can override the image command with node /app/dist/cli/index.js serve --transport stdio --config <path> and do not need to publish a port.

Vercel

The repository includes one stateless Node.js Function at /api/mcp. Set BRANDKIT_AUTH_TOKEN in every Vercel environment and send it as a Bearer token. Vercel's VERCEL_URL and VERCEL_PROJECT_PRODUCTION_URL are trusted automatically. For a custom domain, set BRANDKIT_ALLOWED_HOSTS to a comma-separated hostname list, without schemes or paths.

The default deployment explicitly bundles templates/starter/** and serves that data read-only. To deploy another brand, set BRANDKIT_CONFIG to its repository-relative config path and update functions.api/mcp.js.includeFiles in vercel.json to include both that config and its complete brand root. Vercel runtime files are immutable; the function never advertises sync_brand_docs. Each request creates and closes its own MCP server and transport, so requests do not depend on a warm instance or session affinity.

CLI Reference

brandkit-mcp <command> [options]

Commands:
  init [directory]      Scaffold a brand atomic system from the starter template
  validate [config]     Validate configuration and scan for issues
  serve                 Start the MCP server
  preview               Start the local preview UI for browsing the brand atomic system
  docs                  Generate project documentation files

Global Options:
  --version             Show version number
  --help                Show help

serve accepts --transport <stdio|sse|http>, --host <host>, --port <number>, --config <path>, --watch, and the privileged network option --allow-write-tools.

Contributing

Contributions are welcome.

git clone https://github.com/ejwhite7/brandkit-mcp
cd brandkit-mcp
npm install
npm run build
npm test

TypeScript strict mode
ESM imports with .js extensions
No any types -- use proper interfaces
Tests use Vitest

License

MIT -- see LICENSE for details.

Built with the Model Context Protocol by Anthropic.

Available Tools

12 tools

get_brand_overviewA

Get a high-level overview of the design system: brand name, active contexts, asset inventory counts, and available design system sections.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully bears the burden. It discloses that the tool returns brand name, active contexts, inventory counts, and sections. It does not mention side effects or permissions, but as a read-only overview, the absence is acceptable.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, well-formed sentence with no superfluous words. It front-loads the purpose and lists contents concisely.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no parameters, no output schema, and low complexity, the description adequately covers what the tool returns. It could mention read-only nature or response format, but is sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so no parameter documentation is needed. A baseline of 4 is appropriate as the description adds no parameter info but does not need to.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Get') and resource ('high-level overview of the design system'), listing exact contents: brand name, active contexts, asset inventory counts, and sections. This clearly differentiates from sibling tools that focus on specific aspects (e.g., get_colors, get_components).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use when a summary is needed before diving into specific design system elements, but lacks explicit when-not-to-use or alternative guidance. It is still clear enough for an AI to infer appropriate usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_colorsA

Get the color palette with hex values, RGB values, usage guidelines, and semantic roles. Supports context filtering (marketing vs product) and output format selection.

ParametersJSON Schema

Name	Required	Description	Default
`context`	No	Design context to query	all
`role`	No	Filter by semantic role: primary, secondary, accent, neutral, error, success, warning, info
`format`	No	Output format	json

TDQS

A3.6/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses basic return contents (hex, RGB, guidelines, roles) and filtering options, but does not mention any behavioral traits like data source, caching, read-only semantics, or error scenarios.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences, front-loaded with core purpose, then additional capabilities. Every sentence adds value without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no required parameters, no output schema, and no annotations, the description adequately covers the tool's output and filtering options. It lacks details on return structure or error handling, but is sufficient for a simple retrieval tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3. The description adds context about filtering ('marketing vs product') and output format selection, but does not significantly enhance meaning beyond the schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves the color palette with specific elements (hex, RGB, usage guidelines, semantic roles). It distinguishes from siblings like get_tokens and get_typography by focusing on color-specific data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for retrieving color palette with optional filtering, but does not explicitly mention when to use this over alternatives (e.g., get_tokens) or provide 'when not to use' guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_componentsA

Get component specifications, variants, CSS properties, and usage guidelines. Filter by context (marketing vs product) or category.

ParametersJSON Schema

Name	Required	Description	Default
`context`	No	Design context to query	all
`category`	No	Filter by category: button, form, navigation, layout, card, modal, etc.
`name`	No	Search by component name (partial match, case-insensitive)

TDQS

A3.6/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description does not disclose behavioral traits like read-only nature, authentication needs, or rate limits, leaving the agent without necessary context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that efficiently conveys the tool's purpose and filtering options without unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite no output schema, the description lists what the tool returns (specifications, variants, CSS, guidelines) and filtering options, making it reasonably complete for a read-only tool with optional parameters.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% coverage with parameter descriptions, so the baseline is 3. The description adds context about component content but doesn't enhance parameter meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description explicitly states the tool retrieves component specifications, variants, CSS properties, and usage guidelines, distinguishing it from siblings like get_css and get_guidelines by combining multiple aspects.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description mentions filtering by context and category, implying usage scenarios, but does not explicitly state when to use this tool versus alternatives or provide exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_context_diffA

Compare marketing site vs product app design systems side-by-side, highlighting differences in colors, typography, and components.

ParametersJSON Schema

Name	Required	Description	Default
`category`	No	Category to compare	all

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It describes the core behavior (comparing and highlighting differences), but it does not disclose the output format, potential side effects, permissions, or rate limits. The behavior is simple and likely read-only, but the lack of output description is a gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, short sentence (18 words) that conveys the entire purpose without any fluff. Every word earns its place, making it highly concise and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (one parameter, no nested objects, no output schema), the description covers the main intent well. However, it does not describe the output format (e.g., what a 'highlight' looks like). Nonetheless, the context of sibling tools and the clear purpose makes it reasonably complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema coverage is 100% for the single parameter, and the schema description covers the enum values. The tool description mentions 'colors, typography, and components,' which aligns with the enum, adding marginal context. Since schema already provides good coverage, baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool compares two specific design systems (marketing site vs product app) side-by-side, focusing on differences in colors, typography, and components. This specific verb-resource combination distinguishes it from sibling tools that retrieve individual elements or overviews.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when needing a side-by-side comparison of the two design systems. It provides clear context but does not explicitly state when not to use or mention alternatives, such as using individual get_* tools for a single system. Since siblings are listed, the context is fairly clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_cssB

Get raw CSS file contents and extracted custom property definitions from the design system.

ParametersJSON Schema

Name	Required	Description	Default
`context`	No	Design context to query	all
`includeRaw`	No	Include full raw CSS file contents (can be large)

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description should disclose behavioral traits. It does not warn that includeRaw=true can return large data, nor explain what 'extracted custom property definitions' means in terms of output structure. No details on performance or side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no unnecessary words. It is front-loaded with the action 'Get'. However, it could benefit from more details without losing conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and no annotations, the description is insufficient. It does not mention return structure, error conditions, or scope limitations. For a tool with moderate complexity, this leaves gaps for the agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3. The description adds no extra meaning beyond the schema; it implies inclusion of raw CSS and custom properties but does not explicitly map to parameters or clarify the output.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves raw CSS file contents and custom property definitions from the design system. This specific verb-resource combination distinguishes it from sibling tools like get_tokens or get_colors.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like get_tokens or get_typography. The description does not mention scenarios suited for raw CSS retrieval or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_guidelinesA

Get brand guidelines, voice and tone documentation, accessibility rules, and usage policies. Returns full markdown content.

ParametersJSON Schema

Name	Required	Description	Default
`context`	No	Design context to query	all
`section`	No	Filter by section: brand-voice, accessibility, logo-usage, typography, colors, general

TDQS

A3.7/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden of disclosing behavior. It states that the tool returns 'full markdown content', which is informative but does not mention whether the operation is read-only (likely), requires authentication, or has any side effects. The behavior is minimally disclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences long, front-loading the core purpose. Every sentence provides necessary information without extraneous content. It is appropriately concise and structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has two parameters, no output schema, and no annotations. The description explains the purpose and output format adequately, but does not clarify how the 'context' and 'section' parameters interact (e.g., are they combined or exclusive?), nor does it detail the structure of the returned markdown. Given the simplicity, it is minimally complete but has gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has two parameters with descriptions and an enum for 'context'. The description adds that the output is 'full markdown content', but does not add specific meaning to the parameters beyond what the schema already covers. Since schema description coverage is 100%, a baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves brand guidelines, voice and tone documentation, accessibility rules, and usage policies. It uses a specific verb ('Get') and resource, and distinguishes itself from sibling tools like get_colors or get_logos by being the comprehensive guidelines tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool is for obtaining a broad set of guidelines, but it does not provide explicit guidance on when to use this tool versus the many sibling tools (e.g., get_brand_overview, get_colors). An agent would benefit from knowing that this returns a broader document, while other tools return specific subsets.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_logosA

Get logo variants (primary, mark, wordmark, monochrome) with usage guidelines, minimum sizes, clear space rules, and forbidden uses. Optionally returns base64-encoded image data.

ParametersJSON Schema

Name	Required	Description	Default
`variant`	No	Filter by variant name (e.g., 'primary', 'mark', 'wordmark')
`format`	No	Whether to include base64 data	metadata

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must cover behavioral aspects. It discloses optional base64 data return but omits details on rate limits, authentication requirements, or whether the data is cached. The description is adequate but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, well-structured sentence that quickly conveys the tool's purpose and key features. Every part is relevant and front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of annotations and output schema, the description covers the main functionality well. It specifies what is returned (variants, guidelines, base64). A small gap is that it doesn't describe the output format for metadata, but it is relatively complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The description adds minimal value beyond the schema: it repeats the variant filtering and format options. It mentions usage guidelines but these are not parameters. No significant extra semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves logo variants with specific features like usage guidelines and minimum sizes. It distinguishes itself from sibling tools such as get_colors and get_typography by focusing on logos.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for obtaining logos but lacks explicit guidance on when to use it versus alternatives like search_brand or get_brand_overview. No when-not or exclusion criteria are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_texturesA

Get texture and pattern assets with usage context. Returns metadata and optionally base64-encoded image data.

ParametersJSON Schema

Name	Required	Description	Default
`context`	No	Design context to query	all

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description indicates a read operation and mentions optional base64 data, but lacks details on permissions, side effects, or exact metadata structure, making it moderately transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two concise sentences with no superfluous information, efficiently covering the tool's purpose and output.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter retrieval tool with full schema coverage, the description adequately covers functionality and output, though it could mention default behavior or filtering options.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the description adds only 'with usage context' which aligns with the 'context' parameter, but does not enhance understanding beyond the schema's enum descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it retrieves texture and pattern assets with usage context, and specifies it returns metadata and optionally base64 image data, distinctly differentiating it from sibling tools like get_colors and get_logos.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage context for querying textures but does not provide explicit guidance on when to use this tool versus alternatives or when not to use it, relying on the tool name and context parameter.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_tokensA

Export design tokens in a specific format: CSS custom properties, SCSS variables, Tailwind config, W3C Design Tokens format, or JSON.

ParametersJSON Schema

Name	Required	Description	Default
`context`	No	Design context to query	all
`format`	Yes	Output format (required)
`category`	No	Token category to export	all

TDQS

A3.6/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description carries the burden. It implies a read-only export but does not explicitly state side effects, permissions, or rate limits. The behavior is adequately suggested but not fully transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that efficiently conveys the core purpose and key options. However, it is somewhat dense and could benefit from slight restructuring for readability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers the input parameters but fails to describe the output format or response structure, especially given the absence of an output schema. For a simple export tool, it is adequate but not complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the description adds minimal new meaning beyond the parameter descriptions. It repeats the format options but does not clarify when each is appropriate or how to use them.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool exports design tokens and lists the supported output formats (CSS, SCSS, Tailwind, W3C, JSON). This distinguishes it from sibling tools like get_css or get_colors, which focus on specific subsets.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide guidance on when to use this tool versus alternatives, nor does it explain which format to choose or any prerequisites. The agent receives no usage context beyond the format list.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_typographyB

Get typography specifications: font families, sizes, weights, line heights, and usage guidelines per context.

ParametersJSON Schema

Name	Required	Description	Default
`context`	No	Design context to query	all
`format`	No	Output format	json

TDQS

B3.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description offers no behavioral details beyond indicating it retrieves data. It does not mention authentication, rate limits, or data freshness, leaving the agent with minimal insight into side effects or constraints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence of 11 words that immediately conveys the tool's purpose and scope. No superfluous words or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple with two enum parameters and no output schema. The description lists the returned data types and mentions 'per context', which is adequate. It might briefly note default parameter values, but overall it is complete for its complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema covers both parameters with descriptions (100% coverage). The description adds context by listing the spec elements retrieved (e.g., font families, sizes) and mentions 'per context', which ties to the context parameter. However, it does not enhance the format parameter, so the added value is moderate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves typography specifications, listing font families, sizes, weights, line heights, and usage guidelines per context. It distinguishes itself from siblings like get_colors or get_logos by specifying typography-specific content.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives like get_css or get_tokens. The description implies context-based usage but does not elaborate on selecting between contexts or other tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_brandA

Full-text search across all design system content: guidelines, component specs, color names, typography definitions, and brand documentation.

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes	Search query
`context`	No	Design context to search within	all
`limit`	No	Maximum number of results to return

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It only mentions 'full-text search' without detailing any behavioral traits such as pagination, error handling, rate limits, or what happens when no results are found.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, focused sentence that front-loads the purpose and lists key content categories. Every word adds value, and there is no superfluous information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has multiple parameters and no output schema, the description is somewhat complete in defining the search scope, but it lacks details about output format, ordering, or limits on search behavior, which weakens completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so parameters are already well-documented. The description adds context about the search scope (design system content) but does not provide additional semantics beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Full-text search across all design system content' and enumerates specific content types (guidelines, component specs, color names, etc.), making the tool's purpose explicit and distinguishing it from the many get_* sibling tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool is for broad search across all design system content, in contrast to sibling tools like get_colors which retrieve specific items, but it does not explicitly state when to use this versus alternatives or when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

validate_usageA

Validate whether a specific color, font, or logo usage complies with the brand guidelines. Returns pass/fail with specific guidance.

ParametersJSON Schema

Name	Required	Description
`type`	Yes	What to validate
`value`	Yes	The color hex/name, font name, or logo variant to validate
`context`	No	Context to validate against
`useCase`	No	Description of how it's being used

TDQS

A4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavior. It states the tool returns 'pass/fail with specific guidance', which is transparent about output. However, it does not explicitly state that the tool is read-only or has no side effects, but the word 'validate' implies a safe operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that is direct and front-loaded with the tool's purpose. It contains no unnecessary words and clearly communicates the core function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 4 parameters and no output schema, the description is fairly complete: it explains the validation logic and the return format (pass/fail with guidance). However, it could include more detail on the 'specific guidance' or edge cases, but overall it provides sufficient context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% coverage for parameter descriptions, so the description adds little beyond summarizing the types ('color, font, or logo'). It does not provide additional context or usage examples for the parameters, meeting the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it validates compliance for color, font, or logo usage against brand guidelines. It distinguishes itself from sibling tools (which are retrieval-focused like 'get_colors' or 'search_brand') by being a validation tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use (for checking compliance) but does not mention when not to use it or suggest alternative tools. Since siblings are mostly read tools, a brief note about using this for validation vs. retrieval would improve guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

12 tool updatesv0.1.0May 4, 2026
- First observedget_brand_overview
- First observedget_colors
- First observedget_components
- First observedget_context_diff
- First observedget_css
- First observedget_guidelines
- First observedget_logos
- First observedget_textures
- First observedget_tokens
- First observedget_typography
- First observedsearch_brand
- First observedvalidate_usage

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.8/5.0

Disambiguation5/5

Each tool targets a distinct aspect of the brand/design system: overview, colors, components, context diff, CSS, guidelines, logos, textures, tokens, typography, search, and validation. No two tools have overlapping purposes.

Naming Consistency4/5

10 of 12 tools follow the 'get_' verb_noun pattern (e.g., get_colors, get_components). However, 'search_brand' and 'validate_usage' break this pattern by using different verbs, introducing slight inconsistency.

Tool Count5/5

With 12 tools, the count is well within the optimal 3-15 range. Each tool represents a meaningful and distinct function for managing a brand kit, neither too few nor too many.

Completeness4/5

The set covers core retrieval and validation operations for brand assets (colors, typography, logos, etc.) and includes search and diff capabilities. The absence of mutation tools (create/update/delete) is a minor gap, but likely intentional for a read-only inspection server.

Maintenance

ActivityMaintained

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Pixelixe
com.pixelixe
Brand-safe MCP for AI agents to create editable, on-brand graphics and automate variants.
Design Tools Marketing App Automation
2
ThinkNEO Control Plane C
ai.thinkneo
Enterprise AI Control Plane: governance, guardrails, spend tracking, compliance & smart routing.
Monitoring Observability Security
6823
IdentArk Gateway
io.identark
Zero-secret MCP gateway for AI agents: risk-scored, audited calls with human-in-the-loop approval.
Security Agent Orchestration
29
gateway
works.jinn
Jinn gateway MCP — brand DNA, brand kits, design systems, and agency tools behind one bearer token.
Design Tools Marketing
2

Related MCP Servers

agent-guard-mcp
Autonomous Agents Security Monitoring
dygogogo
A
license
Not graded
quality
D
maintenance
MCP Guard Server - Budget control, approval workflows and audit logging for AI agents (Claude Code, Cursor, ChatGPT)
Updated 5 months ago (2026-04-10 05:52 UTC)
MIT
guardrails-mcp-server
Security AI & Machine Learning
ExpertVagabond
A
license
Not graded
quality
B
maintenance
MCP server for AI agent security guardrails. Provides input validation, prompt injection detection, PII redaction, output filtering, policy enforcement, rate limiting, and comprehensive audit logging.
Updated 8 days ago (2026-08-28 17:38 UTC)
76
1
MIT
OnBrand by SlideSpeakofficial
Design Tools Marketing
SlideSpeak
A
license
Not graded
quality
A
maintenance
An MCP server that feeds AI agents your brand's real logos, colors, fonts, and approved slide layouts, so every deck and document comes out on brand the first time.
Updated 12 days ago (2026-08-24 05:35 UTC)
6
MIT
Brand Registry
Marketing Design Tools Documentation Access
scottwittrock
A
license
Not graded
quality
B
maintenance
MCP server that exposes brand identity guidelines (visual look and voice) as markdown, enabling LLMs to produce on-brand content.
Updated 2 months ago (2026-07-18 17:12 UTC)
16
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/ejwhite7/brandkit-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

BrandKit MCP

Quick Start

Repository Structure

MCP Tools Reference

Taste primer

MCP Resources

Configuration

Context System

Migrating from v1

Conventions

Docker Compose

Vercel

CLI Reference

Contributing

License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

OnBrand by SlideSpeakofficial

Latest Blog Posts

MCP directory API