The Tabler MCP Server integrates the Tabler.io UI kit into AI assistants, enabling accurate, hallucination-free use of Tabler icons, components, layouts, themes, and documentation.
Search Icons — Search 5,000+ icons by keyword, tag, or category, with optional filtering by style (outline/filled)
Get Icon — Retrieve any icon as SVG, React, Vue, Svelte component, webfont class, or data URI, with customizable size, stroke, and color
List Icon Categories — Browse all icon categories with their icon counts
List UI Components — Explore ~40 UI components (alerts, cards, modals, forms, badges, buttons, etc.) with optional keyword filtering
Get Component — Retrieve ready-to-paste HTML snippets for any Tabler component using Tabler 1.4 markup
Get Page Layout — Generate complete HTML pages for layouts such as horizontal, vertical, condensed, fluid, login, register, forgot-password, error-404, error-500, or blank, with optional dark/light theme
Get Starter Template — Generate a minimal HTML starter document with CDN links, optional dark mode, plugin stylesheets, and icon webfont
Get Color Palette — Retrieve the official Tabler color palette including hex values, CSS variables, and utility classes
Get Theme Info — Learn how to enable dark mode, persist theme preferences, and customize Tabler via CSS variables
Search Documentation — Search docs.tabler.io (UI, icons, emails, illustrations) by keyword and get relevant page URLs
Read Docs Page — Fetch any docs.tabler.io page as clean readable text, including headings, paragraphs, and code blocks
Get Installation Instructions — Retrieve up-to-date CDN links and npm package info for Tabler UI and Tabler Icons
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Tabler MCP Server Build me a Tabler login page in dark mode"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server for Tabler.io — bring 5,000+ Tabler icons, the full UI component catalogue, page layouts, themes and live documentation into Claude, Cursor, and any MCP-compatible AI assistant.
Created by Mafady AI Studio — Supervised by Dr Maher · Version française ci-dessous 🇫🇷
https://github.com/user-attachments/assets/a4c7c7d7-4366-475d-8bff-2d084cbe50cc
Tabler is one of the most popular open-source dashboard UI kits (41k+ ⭐, Bootstrap 5, MIT). This server teaches your AI assistant to use it correctly: exact icon names, canonical component markup, official color palette, real CDN links — instead of hallucinated class names.
Icon search and component snippets work fully offline (data ships with the package). Documentation search uses docs.tabler.io live.
Related MCP server: Noun MCP Server
Tool | Description |
| Search 5,000+ Tabler icons by keyword, tag or category |
| Get an icon as SVG (custom size/stroke/color), React, Vue, Svelte, webfont or data URI |
| All icon categories with counts |
| Catalogue of ~40 UI components (alerts, cards, modals, tables, forms…) |
| Ready-to-paste HTML snippets for a component, Tabler 1.4 markup |
| Complete HTML page: horizontal / vertical / condensed / fluid layout, login, register, forgot-password, 404, 500, blank |
| Minimal starter HTML with CDN links, dark mode, plugin stylesheets |
| Official color palette with hex, CSS variables and utility classes |
| Dark mode, theme persistence and CSS-variable customization |
| Search docs.tabler.io pages (UI, icons, emails, illustrations) |
| Read any docs.tabler.io page as clean text |
| Up-to-date CDN links and npm packages for Tabler UI & Icons |
Requires Node.js ≥ 18.
claude mcp add tabler -- npx -y tabler-mcp-serverAdd to claude_desktop_config.json (Settings → Developer → Edit Config):
{
"mcpServers": {
"tabler": {
"command": "npx",
"args": ["-y", "tabler-mcp-server"]
}
}
}{
"mcpServers": {
"tabler": {
"command": "npx",
"args": ["-y", "tabler-mcp-server"]
}
}
}ChatGPT connectors require a remote server. Expose this stdio server over HTTP with a gateway, e.g.:
npx -y supergateway --stdio "npx -y tabler-mcp-server" --port 8000git clone https://github.com/MaFady/tabler-mcp-server.git
cd tabler-mcp-server
npm install && npm run build
node dist/index.js # stdio MCP serverThen point your client at node /path/to/tabler-mcp-server/dist/index.js.
📘 New here? Follow the step-by-step Getting Started guide (English & français) — a task-by-task walkthrough of every tool.
"Build me a Tabler login page in dark mode for 'Acme Cloud'"
"Find a Tabler icon for invoices and give me the React component"
"Create a dashboard card with a ribbon and a progress bar using Tabler"
"What's the exact hex of Tabler's danger color?"
"Show me the Tabler docs about form validation"
examples/dashboard.html is a complete dashboard generated by this server's own engines (icon engine + template builder) — open it in a browser, or regenerate it:
npm run build && node examples/generate-demo.mjsnpm install
npm run dev # run from TypeScript (tsx)
npm test # vitest
npm run build # compile to dist/Project layout:
src/
index.ts # stdio entry point
server.ts # MCP server + 12 tool registrations
icons.ts # offline icon search/render engine (@tabler/icons data)
docs.ts # live docs.tabler.io search & page reader
template.ts # HTML document builder
data/
components.ts # curated component snippets (Tabler 1.4 markup)
layouts.ts # full-page layout skeletons
colors.ts # official palette (extracted from tabler.min.css)Generated templates reference the official jsDelivr CDN. For production apps, pin versions and consider adding Subresource Integrity attributes to CDN tags.
Server code: MIT © 2026 Mafady AI Studio — Supervised by Dr Maher
Tabler, Tabler Icons © Paweł Kuna and contributors (MIT)
This is an independent community project, not affiliated with or endorsed by Tabler
Serveur MCP pour Tabler.io — apportez plus de 5 000 icônes Tabler, le catalogue complet de composants UI, les layouts de pages, les thèmes et la documentation en direct dans Claude, Cursor et tout assistant IA compatible MCP.
Tabler est l'un des kits UI de dashboard open source les plus populaires (41k+ ⭐, Bootstrap 5, MIT). Ce serveur apprend à votre assistant IA à l'utiliser correctement : noms d'icônes exacts, markup canonique des composants, palette officielle, vrais liens CDN — au lieu de classes CSS hallucinées.
La recherche d'icônes et les snippets fonctionnent entièrement hors-ligne ; la recherche documentaire interroge docs.tabler.io en direct.
{
"mcpServers": {
"tabler": {
"command": "npx",
"args": ["-y", "tabler-mcp-server"]
}
}
}📘 Nouveau ? Suivez le guide de démarrage pas à pas (anglais & français) — un parcours tâche par tâche de chaque outil.
« Crée-moi une page de connexion Tabler en mode sombre pour "Acme Cloud" »
« Trouve une icône Tabler pour les factures et donne-moi le composant React »
« Quel est le hex exact de la couleur danger de Tabler ? »
Créé par le studio IA Mafady — Supervisé par Dr Maher · Licence MIT · Projet communautaire indépendant, non affilié à Tabler.
Get the official Tabler color palette (base colors, semantic theme colors, gray scale) with hex values, CSS variables and utility classes.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. 'Get' implies a read-only operation with no side effects, and listing the return content (hex, CSS variables, utility classes) sets accurate expectations. However, it does not explicitly state that the operation is safe or idempotent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that promptly states the purpose and key details. Every word is informative, with no unnecessary filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter retrieval tool with no output schema, the description fully covers what the tool returns and its format. It is complete and leaves no ambiguity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so the baseline is 4. The description does not need to elaborate on parameters, and it correctly omits any parameter information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 ('Tabler color palette'), listing the exact content (base colors, semantic theme colors, gray scale) and format (hex values, CSS variables, utility classes). It clearly distinguishes from sibling tools which target components, icons, or docs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. While the sibling tool names and purpose make it clear that this is for color palettes, the description does not mention use cases, prerequisites, or contrast with other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get ready-to-paste HTML snippets for a Tabler UI component (markup follows @tabler/core 1.4.0 conventions), plus requirements and documentation link.
| Name | Required | Description | Default |
|---|---|---|---|
| component | Yes | Component slug or name, e.g. 'card', 'modal', 'forms' (see list_components) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided. The description discloses returns (HTML snippets, requirements, documentation link) but does not mention side effects, authentication needs, or rate limits. It adds some context beyond the name but leaves behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single, front-loaded sentence that efficiently conveys purpose, content, and context. Every word earns its place, no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 1-parameter, no-output-schema tool, the description covers purpose, parameter examples, and return contents (HTML, requirements, docs link). It omits error behavior or format details but is adequate for the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with one parameter 'component' described as 'Component slug or name, e.g. 'card', 'modal', 'forms' (see list_components)'. The description adds examples and a cross-reference, providing more meaning than the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly specifies 'Get ready-to-paste HTML snippets for a Tabler UI component', identifying the verb (Get) and resource (HTML snippets). It also mentions conventions, requirements, and documentation link, distinguishing it from sibling tools like list_components.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description implies usage context by referencing list_components for obtaining component slugs, but lacks explicit when-to-use or when-not-to-use guidance relative to other tools like get_docs_page or search_docs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch a docs.tabler.io page and return its readable text content (headings, text, code blocks). Requires network access.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Full URL or path, e.g. 'https://docs.tabler.io/ui/components/modals' or 'ui/components/modals' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry full behavioral transparency. It states the tool returns text content and requires network access, but omits details about error handling (e.g., 404, invalid URL), rate limits, authentication, or caching behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (two sentences) and front-loaded: first sentence defines purpose and output, second adds requirement. Every word adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple fetch tool with one parameter and no output schema, the description is fairly complete: it specifies output format, network requirement, and URL type. However, it could mention behavior for invalid URLs or relative paths, though the example clarifies path format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (one parameter with description). The tool description adds no additional parameter semantics beyond what the schema already provides ('Full URL or path'). Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Fetch' and clearly identifies the resource (docs.tabler.io page) and output (readable text content: headings, text, code blocks). It distinguishes clearly from sibling tools, which focus on colors, icons, or components.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions a prerequisite ('Requires network access') but provides no guidance on when to use this tool versus alternatives, nor when not to use it. It does not reference sibling tools or give context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a Tabler icon by exact name in the requested format: raw SVG (customizable size/stroke/color), React, Vue, Svelte, webfont class, or data URI.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Exact icon name, e.g. 'heart', 'shopping-cart' (find names with search_icons) | |
| size | No | Size in px (default 24) | |
| color | No | CSS color to replace currentColor, e.g. '#d63939' or 'var(--tblr-primary)' | |
| style | No | Icon style (default: outline) | |
| format | No | Output format (default: svg) | |
| strokeWidth | No | Stroke width for outline style (default 2) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Discloses that output can be customized via parameters (size, stroke, color). Does not mention error behavior on missing name, but for a read-only retrieval this 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence front-loads purpose and lists formats efficiently. No redundant words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 6 parameters and no output schema, description covers core functionality and customization. Could be more complete with examples or default hints, but sibling tools add context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are already documented. Description adds value by grouping customization params and emphasizing 'exact name', but does not provide detailed syntax beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves a specific Tabler icon by exact name in multiple output formats (SVG, React, etc.). It distinguishes from siblings like search_icons and list_icon_categories by emphasizing 'exact name' and formats.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies usage: call when you know the exact icon name; references search_icons to find names. Lacks explicit when-not or alternatives, but context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Up-to-date installation options for Tabler UI and Tabler Icons: CDN links, npm packages, plugin stylesheets.
| Name | Required | Description | Default |
|---|---|---|---|
| product | No | Which product (default: ui) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, but the description lists outputs (CDN links, npm packages, plugin stylesheets) and notes timeliness. It lacks details on authentication or limitations, but for a read-only tool this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence efficiently conveys core content without unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description sufficiently covers the tool's purpose and output for its simplicity, though it could specify the return format (e.g., code snippets) to be fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of the single parameter with description and enum. The tool description reinforces the product choices but adds no new meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves up-to-date installation options for Tabler UI and Icons, specifying resources (CDN, npm, stylesheets). It distinguishes from sibling tools like get_component or get_icon.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for obtaining installation info but offers no explicit guidance on when to use or avoid, nor mentions alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a complete, ready-to-run HTML page for a Tabler layout: horizontal (top navbar), vertical (sidebar), condensed, fluid, login, register, forgot-password, error-404, error-500, or blank.
| Name | Required | Description | Default |
|---|---|---|---|
| theme | No | Color scheme (default: light) | |
| title | No | App/brand title injected into the page (default: 'Tabler App') | |
| layout | Yes | Layout to generate |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of behavioral disclosure. It states the output is a 'complete, ready-to-run HTML page' but does not mention side effects, auth requirements, rate limits, or whether the operation is read-only. Minimal transparency beyond the core action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that efficiently conveys the tool's function and enumerates all layout options. No extraneous text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The schema fully documents parameters, and the description provides a high-level summary. However, the absence of an output schema or return format details (e.g., whether the HTML is responsive, includes scripts) leaves some gaps. Adequate but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the description adds marginal value. It repeats the layout options from the schema but does not provide additional context like default values or interaction between parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets a complete, ready-to-run HTML page for a Tabler layout and enumerates the ten specific layout types. This distinguishes it from siblings like get_component or get_starter_template.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives (e.g., get_component for individual components, get_starter_template for starter templates). No explicit context for when-not-to-use is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a minimal Tabler starter HTML document with CDN links (CSS+JS), optional dark theme, optional plugin stylesheets (flags, payments, socials, vendors) and optional Tabler Icons webfont.
| Name | Required | Description | Default |
|---|---|---|---|
| theme | No | Color scheme (default: light) | |
| title | No | Page title (default: 'Tabler App') | |
| plugins | No | Extra Tabler plugin stylesheets to include | |
| iconsWebfont | No | Include the Tabler Icons webfont stylesheet |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It describes the generation action and options but does not specify the output format (string, file?) or mention any side effects, permissions, or rate limits. The mention of CDN links hints at external dependencies but is not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single clear sentence that front-loads the core purpose and lists all optional customizations. Every word adds value, no redundancy, and it is appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 covers the purpose and parameter options well. However, it could be more complete by explicitly stating the output type (e.g., 'returns HTML as a string'). Still, it provides enough context for basic use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 summarises the parameters (dark theme, plugins, icons) but adds no new semantics beyond what the schema already provides. It correctly maps to the schema enums and defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it generates a minimal Tabler starter HTML document with CDN links and optional settings. The verb 'generate' and resource 'starter HTML template' are specific, and it distinguishes from siblings like get_component or get_page_layout which focus on individual parts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for creating a starter template but does not explicitly state when to use this versus alternatives like get_component or get_page_layout. No when-not-to-use or alternative guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
How to enable dark mode, persist theme choice, and customize Tabler via CSS variables.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description fails to disclose any behavioral traits such as whether this tool performs a read operation, its side effects, or any limitations. The focus on 'how to' misrepresents the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, but it is not front-loaded with the tool's purpose. It reads as a how-to guide rather than a clear statement of what the tool does, making it less effective despite its brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Without an output schema, the description should explain what the tool returns. Instead, it describes a process ('how to enable...'), leaving the actual functionality unclear. The description is incomplete for a zero-parameter tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters, so schema coverage is 100%. The description does not need to add parameter details, meeting the baseline for this dimension.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description says 'How to enable dark mode...' which is instructional rather than stating what the tool returns. It implies a guide, not a retrieval function, making the purpose vague and potentially misleading.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus siblings like get_colors or get_component. The description does not specify any context or prerequisites for using the tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List the Tabler UI component catalogue (alerts, avatars, badges, buttons, cards, modals, tables, forms...). Optionally filter with a query. Use get_component for HTML snippets.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | Optional filter, e.g. 'form', 'card' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool lists components with optional filtering, but does not mention return format, pagination, case sensitivity, or any side effects. As a read operation, this is minimally adequate but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, front-loaded with the primary purpose, and contains no redundant words. Every sentence serves a purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one optional parameter, no output schema), the description covers the main functionality and usage. It could mention that it returns a list or catalogue, but the purpose is clear. Lacks details on ordering or pagination, but these are not critical for this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with the 'query' parameter described in the schema as 'Optional filter, e.g. form, card'. The description rephrases this as 'Optionally filter with a query.' Since the schema already covers the meaning, the description adds no new value, resulting in a baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it lists Tabler UI components with examples like alerts, avatars, badges. It distinguishes from the sibling tool 'get_component' by directing users there for HTML snippets.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use this tool (list components) and provides an alternative ('get_component' for HTML snippets). It also mentions optional filtering by query, but does not explicitly state when not to use it or compare with other listing tools like 'list_icon_categories'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all Tabler icon categories with icon counts.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It states 'List all', indicating a read-only operation returning all categories with counts. No hidden behaviors disclosed, but for a simple list, this is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no waste; front-loaded with verb and resource. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters, no output schema, and simple list operation, the description is complete enough. Could optionally mention output format, but not required.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so baseline 4 applies. Description adds no parameter info, which is appropriate given the absence of parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List', the resource 'Tabler icon categories', and adds 'with icon counts', making the purpose specific and distinguishable from sibling tools like search_icons or get_icon.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use (when needing icon categories), but lacks explicit guidance on when not to use or how it compares to other list tools like list_components.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search docs.tabler.io pages (UI, icons, emails, illustrations) by keyword. Returns page URLs — use get_docs_page to read one. Requires network access.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default 10) | |
| query | Yes | Keywords, e.g. 'modal', 'installation', 'react icons' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description adds 'Requires network access' as a behavioral trait. It does not disclose potential rate limits, result ordering, or whether it's a read-only operation. Adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose, and contains no unnecessary words. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description explains the return type (page URLs) and mentions a related tool for consuming results. It covers the key aspects, though it could mention result ordering or pagination behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear descriptions for both parameters (query, limit). The description adds no additional parameter-level information beyond the schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Search docs.tabler.io pages (UI, icons, emails, illustrations) by keyword' and specifies the return type as page URLs, with a note to use get_docs_page for reading. This distinguishes it from siblings like search_icons and get_docs_page.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides an alternative tool (get_docs_page) and implicitly indicates this tool is for keyword-based page search. However, it lacks explicit when-not-to-use guidance or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search 5,000+ free Tabler icons by keyword, tag or category. Returns icon names, categories, tags and available styles (outline/filled). Use get_icon to retrieve the actual SVG or framework code.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default 20) | |
| query | Yes | Search keywords, e.g. 'shopping cart', 'arrow left', 'user' | |
| style | No | Only icons available in this style | |
| category | No | Filter by category (see list_icon_categories) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description states search returns icon metadata (names, categories, tags, styles) and implies read-only behavior. Does not disclose potential side effects or limitations beyond the search scope.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two efficient sentences. First conveys purpose and output; second directs to next tool. No redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers purpose, search methods, return values, and next steps. Lacks details on pagination or error handling, but sufficient for a search tool with good schema coverage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%. Description adds no new parameter meaning beyond schema examples; baseline rating of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states verb 'Search', resource '5,000+ free Tabler icons', and methods 'by keyword, tag or category'. Differentiates from sibling get_icon by directing users to use that for actual SVG/framework code.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Specifies when to use the tool (search by keyword, tag, category) and directs to get_icon for retrieval, but lacks explicit '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.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0get_colorsget_componentget_docs_pageget_iconget_installationget_page_layoutget_starter_templateget_theme_infolist_componentslist_icon_categoriessearch_docssearch_iconsEach tool has a clearly distinct purpose: retrieving colors, icons, components, layouts, docs, installation, themes, and listing/searching. There is no functional overlap.
All tool names follow a consistent verb_noun pattern (get_*, list_*, search_*), making it predictable for an agent to infer functionality.
12 tools is well-scoped for a UI framework server, covering retrieval, listing, and search without being excessive or insufficient.
The tool set covers all essential operations for a static UI framework: fetching individual resources, listing/searching, installation, and theme info. No obvious gaps for its domain.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
An MCP server that gives your AI access to the source code and docs of all public github repos
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Your org's AI agents, tasks, runs, search, and brain files as MCP tools and resources.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/MaFady/tabler-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
