Tyler Forge logo

Tyler Forge

Organization
tyler-technologies-oss

An MCP server to expose Tyler Forge™ design system and component API documentation to LLMs.

Publishertyler-technologies-oss
Repositoryforge-mcp
LanguageTypeScript
Forks
2
Stars
5
Available tools
14
Transport typestdio
Categories
LicenseApache-2.0
Links
  • Connect tools to AI workflows

    Tyler Forge exposes MCP capabilities that can be used by compatible AI clients and agents.

  • 14 available tools

    Browse the callable actions below, including names and descriptions when provided by the server.

  • Ready-to-copy setup

    Use the installation snippets to configure this server in your preferred MCP client.

  • Open source signals

    5 stars and 2 forks from the linked repository.

Tyler Forge™ MCP Server

Access Tyler Forge™ web component documentation directly in AI clients. Discover components, generate framework-specific code, validate APIs, and use design tokens correctly.

Features

  • Version-aware: Detects your installed Tyler Forge version and provides matching documentation, falling back to the latest published version (fetched from npm) if Forge isn't installed yet, and to a bundled snapshot as a last resort
  • Forge Blocks: Pre-built UI patterns showing components working together in context (forms, tables, layouts, dashboards)—the canonical source of Forge markup for both single components and larger patterns
  • API Quick Reference: Component docs lead with exact events, properties, attributes, slots, and CSS custom properties
  • UI Plans: Generate and validate a machine-checkable plan (scaffold, regions, typography roles, icons) before writing composition-scale markup
  • Component Validation: Verify generated code against actual component APIs
  • Design Tokens: Access colors, spacing, typography, and other design tokens
  • Framework Guides: Setup instructions for Angular, React, Vue, Svelte, and Lit
  • Guardrails (plugin only): PreToolUse/Stop hooks block common anti-patterns (inline styles, hand-rolled layout, skipped validation) as code is written

Setup

Claude Code Plugin (Recommended)

The plugin bundles the MCP server with a /forge-design skill for expert UI guidance.

Install:

bash
/plugin marketplace add tyler-technologies-oss/forge-mcp
/plugin install forge@tyler-forge

Verify installation:

bash
/skills

You may need to restart Claude or run /reload-skills if the skill doesn't appear.

Update the plugin:

bash
claude plugin marketplace update tyler-forge

For local development:

bash
claude --plugin-dir /path/to/forge-mcp/plugin

Claude Code (MCP Only)

bash
claude mcp add -t stdio -s [scope] forge -- npx -y @tylertech/forge-mcp@latest

[scope] must be user, project, or local. See Claude Code MCP docs.

Codex CLI

Add to ~/.codex/config.toml:

toml
[mcp_servers.forge]
command = "npx"
args = ["-y", "@tylertech/forge-mcp@latest"]

Gemini CLI

bash
gemini mcp add -t stdio -s [scope] forge npx -y @tylertech/forge-mcp@latest

VS Code

Add to .vscode/mcp.json:

json
{
  "servers": {
    "forge": {
      "command": "npx",
      "args": ["-y", "@tylertech/forge-mcp@latest"],
      "type": "stdio"
    }
  }
}

Or use Command Palette → MCP: Add Server... → Command (stdio) → enter npx -y @tylertech/forge-mcp@latest.

Claude Desktop

Edit claude_desktop_config.json (Settings → Developer → Edit Config):

json
{
  "mcpServers": {
    "forge": {
      "command": "npx",
      "args": ["-y", "@tylertech/forge-mcp@latest"]
    }
  }
}

Remote (Streamable HTTP)

For a centrally-hosted deployment that any MCP-compatible client (Claude.ai, third-party tools, etc.) can reach over a URL instead of spawning the server locally via npx, run the Streamable HTTP entrypoint:

bash
pnpm run build
pnpm run start:http   # listens on PORT (default 3000), serving POST /mcp

A Dockerfile is included for containerized hosting on any platform that runs a Docker image (Cloud Run, Fly.io, Render, ECS, etc.):

bash
docker build -t forge-mcp-http .
docker run -p 3000:3000 forge-mcp-http

The server is stateless (no Mcp-Session-Id is issued; a fresh server/transport pair handles each request), so it scales horizontally with no session affinity required. GET /healthz returns 200 ok for platform health checks.

Once deployed, point any Streamable HTTP-capable client at https://<your-deployed-url>/mcp, e.g.:

json
{
  "mcpServers": {
    "forge": {
      "type": "http",
      "url": "https://<your-deployed-url>/mcp"
    }
  }
}

Note: Detection of your locally installed @tylertech/forge (see Features above) only works when the server runs on your own machine via stdio, since it inspects your project's node_modules. A remotely hosted instance has no access to your local filesystem, so it always falls through to the same latest-published-version fetch (from npm/unpkg) that stdio uses when Forge isn't installed locally yet. If that fetch fails too (e.g. npm/unpkg is unreachable), it falls back to the bundled documentation baked into the deployed build.

Core Concepts

Forge Blocks

Blocks are pre-built UI patterns that show Forge components working together in context. They demonstrate real-world scenarios like login forms, data tables, application layouts, and dashboards—complete with proper layout, typography, spacing, and component composition.

Why use blocks?

  • See how multiple components work together in realistic scenarios
  • Handcrafted examples following Forge design system best practices
  • Prevent common mistakes and ensure consistent UI patterns

How to use blocks:

# Search for blocks by functionality
get_forge_blocks(query: "login form")
get_forge_blocks(query: "data table with sorting")

# Find blocks using a specific component
get_forge_blocks(component: "forge-card")
get_forge_blocks(component: "forge-table")

# Browse by category
get_forge_blocks(category: "forms")
get_forge_blocks(category: "application-layout")

# Get full code for a specific block
get_forge_blocks(blockId: "src/blocks/forms/login")

Component Documentation

Access complete API documentation—led by an API Quick Reference showing exact events, properties, attributes, slots, and CSS custom properties—so generated code uses the real API instead of a remembered one.

# Full API documentation
get_component_docs(componentName: "forge-dialog")

# Summary overview
get_component_docs(componentName: "forge-dialog", format: "summary")

For HTML usage examples, use get_forge_blocks(component: "forge-dialog") instead—every component has a dedicated block demonstrating its usage.

UI Plans

For anything larger than a single component, generate a machine-checkable plan—scaffold block, regions, typography roles, icons—and validate it before any <forge-*> markup is written.

# Get the plan template and schema/enums to fill in
generate_ui_plan(description: "customer dashboard with a data table and a summary sidebar")

# Validate the composed plan (page_type, regions, block IDs, typography roles, icons, spacing)
validate_ui_plan(plan: { ... })

validate_ui_plan catches structural mistakes early—illegal typography roles, non-token spacing, block IDs that don't exist, composition rules like "no page_title inside a card"—before you've written any code.

Capabilities

Tools

ToolDescription
get_forge_blocksSearch and retrieve pre-built UI patterns (use FIRST before generating UI code)
get_component_docsGet component API documentation (full or summary)
list_componentsBrowse all available components
find_componentsSearch components by name or functionality
generate_ui_planGet the plan template/schema for composition-scale UI (regions, typography roles, icons)
validate_ui_planValidate a composed UI plan before any markup is written
validate_component_apiValidate component API usage in generated code
get_design_tokensGet design tokens (colors, spacing, typography, etc.)
setup_typographyTypography setup and usage guidelines
setup_iconsIcon system installation and usage
find_iconsSearch icons by name or keywords
setup_frameworkFramework-specific setup (Angular, React, Vue, Svelte, Lit)
get_version_migration_guideMigration guides between Forge versions
get_usage_guideGeneral usage patterns and best practices

Resources

URIDescription
forge://componentsAll components overview
forge://component/{tagName}Specific component documentation
forge://installationInstallation guide
forge://usageUsage guide
forge://framework/{name}Framework guides (angular, react, vue, svelte, lit)
forge://design-tokensAll design tokens
forge://design-tokens/{category}Token categories (color, spacing, typography, animation, border, elevation, shape, layering)
forge://iconsIcons guide

Prompts

PromptDescription
forge_modeSets baseline rules for Forge-specific tasks

Recommended Workflow

  1. Search blocks first — Before writing any Forge UI code, call get_forge_blocks to find pre-built patterns and component-specific usage examples
  2. Check component API — Use get_component_docs for full API details when needed
  3. Plan larger UIs — For anything bigger than a single component, call generate_ui_plan then validate_ui_plan; only write markup once the plan validates
  4. Validate before finalizing — Call validate_component_api to verify your code uses correct APIs

Development

Commands:

bash
pnpm run dev    # Watch mode
pnpm run debug  # Test with MCP inspector
pnpm run build  # Build for production

Contributing

See CONTRIBUTING.md for guidelines. Issues and PRs welcome.

License

Apache-2.0 License - see LICENSE file for details.


Note: Always validate AI output against official documentation.

Part of the Tyler Technologies Open Source initiative

Installation

TypingMind
Prerequisites:

Node.js 18+

{
  "mcpServers": {
    "forge": {
      "command": "npx",
      "args": [
        "-y",
        "@tylertech/forge-mcp@latest"
      ]
    }
  }
}

Available Tools

  • get_component_docs

    Get the API contract (properties, attributes, events, slots, CSS parts, CSS vars) for a Tyler Forge component. Call list_components first if you need to discover available components. For HTML usage code, call get_forge_blocks instead — blocks are the sole source of Forge markup.

  • list_components

    Browse all available Tyler Forge components with descriptions. Returns a comprehensive table of all components with their purpose and capabilities.

  • find_components

    Search Tyler Forge components by name, description, or functionality with enhanced fuzzy matching. Supports multi-term queries like "app bar drawer". Returns all components when no query provided.

  • validate_component_api

    Validate Tyler Forge component-specific API usage after code generation. Supports both core components (@tylertech/forge) and extended components (@tylertech/forge-extended). DO NOT use this tool to validate standard HTML attributes (id, class, style, etc.), ARIA attributes (aria-), or data attributes (data-) - these are valid on all elements. Only validate component-specific properties, attributes, events, methods, slots, CSS properties, parts, and classes.

  • get_design_tokens

    Get Tyler Forge design tokens for consistent styling. Access color palettes, spacing scales, typography, animation, and other design system values.

  • setup_typography

    Access Tyler Forge typography setup instructions including font families, type scales, weights, and practical usage guidelines for consistent text styling.

  • setup_icons

    Access Tyler Forge icons system including installation, registration, and usage patterns for the forge-icon component.

  • find_icons

    Search Tyler Icons using semantic/fuzzy search with natural language queries. Finds the closest matching icons by name and keywords.

  • get_usage_guide

    Get comprehensive Tyler Forge guides including installation instructions, framework-specific integration, and general usage patterns

  • setup_framework

    Get complete framework-specific setup instructions for Tyler Forge components including installation, configuration, and best practices.

  • get_version_migration_guide

    Get comprehensive migration guides for upgrading between Tyler Forge versions, including breaking changes, API mappings, and upgrade instructions

  • get_forge_blocks

    Get Forge UI code blocks - pre-built patterns and examples that demonstrate correct Forge component usage. Use this FIRST before generating any Forge UI code to ensure accurate patterns. Can list/search blocks or fetch specific block content.

  • generate_ui_plan

    Emit a machine-checkable UI plan (scaffold block, regions, typography roles, icons) before writing composition-scale Forge markup. Returns the empty plan template and the enums the plan must use. Call validate_ui_plan on the composed plan before writing any <forge-*> markup. See references/ui-plan.md.

  • validate_ui_plan

    Validate a UI plan produced by generate_ui_plan. Checks: page_type enum, region components exist in the CEM, block IDs exist in the block catalogue, typography roles are legal, spacing_scale is tokens-only, icons exist in @tylertech/tyler-icons, and composition rules (no page_title inside card, no hand-rolled tables). Returns pass/fail with per-error hints. Markup must not be written until this returns valid=true.

Use Tyler Forge MCP with multiple AI models

TypingMind connects MCP tools at the workspace level, so once Tyler Forge is connected, you can use it with different AI models in TypingMind instead of setting it up separately for each model. This MCP runs locally through the TypingMind MCP connector on your device.

Setup guide to use the local connector

Use this when the MCP server needs access to local files, apps, or private resources on your computer.

1

Open the MCP settings

In TypingMind, go to Settings, Advanced Settings, then Model Context Protocol and choose Setup Connector.

  1. Open TypingMind in your browser.
  2. Click the Settings icon.
  3. Go to Advanced Settings.
  4. Open the Model Context Protocol section.
  5. Click Setup Connector and choose This Device.
TypingMind MCP connector setup screen with This Device selected
2

Run the connector command

Choose This Device, copy the command from TypingMind, and run it in Terminal. Keep the process running while you use MCP.

  1. Copy the setup command shown by TypingMind.
  2. Open Terminal on macOS or Windows Terminal on Windows.
  3. Paste and run the command.
  4. Approve the package install if Terminal asks you to proceed.
  5. Keep the Terminal window running while using MCP tools.
3

Add Tyler Forge as a server

When the connector status is Ready, click Edit Servers and paste the MCP server configuration.

  1. Wait until the connector status shows Ready.
  2. Click Edit Servers.
  3. Paste the Tyler Forge MCP server configuration.
  4. Save the server list.
  5. Refresh if you want to confirm the connector is still ready.
TypingMind MCP settings showing active server and Edit Servers button
{
  "mcpServers": {
    "tyler-forge": {
      "command": "npx",
      "args": [
        "-y",
        "@tylertech/forge-mcp"
      ]
    }
  }
}
4

Use it across models

Save the server list, open Plugins, enable the Tyler Forge MCP tools, then select any supported AI model in TypingMind and use the tools in chat or assign them to an AI agent.

  1. Open the Plugins page in TypingMind.
  2. Enable the Tyler Forge MCP tools.
  3. Start a chat and choose the AI model you want to use.
  4. Use the MCP tools in chat or assign them to an AI agent.
  5. Switch to another AI model whenever needed without reconnecting MCP.
TypingMind chat using enabled MCP tools with a selected AI model
Can you use Tyler Forge to help me with this task?
Tyler Forge
Sure. I read it.
Here is what I found using Tyler Forge.

Frequently asked questions

What is the Tyler Forge MCP server used for?

Tyler Forge is an MCP server that lets compatible AI clients connect to external tools and context. In TypingMind, you can add this MCP server once and make its tools available in your AI workspace.

Can I use Tyler Forge MCP with multiple AI models in TypingMind?

Yes. TypingMind connects MCP tools at the workspace level, so you can use Tyler Forge with different AI models such as Claude, ChatGPT, Gemini, or other models you have configured in TypingMind without setting up the MCP server separately for each model.

Why use Tyler Forge MCP with TypingMind?

TypingMind is one of the best frontends for LLM chat because it brings multiple AI models, prompts, plugins, AI agents, API keys, and MCP tools into one workspace. With Tyler Forge connected, you can use its MCP tools across your preferred models while keeping your chat workflow organized in TypingMind.

How do I connect Tyler Forge MCP to TypingMind?

Tyler Forge runs through the TypingMind local MCP connector. This is best when the MCP server needs access to local files, desktop apps, command-line tools, or private resources on your computer.

What tools does Tyler Forge MCP provide in TypingMind?

Tyler Forge exposes 14 MCP tools that can be enabled from the TypingMind Plugins page and used in chat or assigned to AI agents.

Do I need to share my API keys with TypingMind to use Tyler Forge MCP?

No. TypingMind is local-first and lets you keep your model providers, API keys, prompts, and MCP configuration under your control. If Tyler Forge requires authentication, add the required headers, OAuth settings, or local configuration for that MCP server when you create the connection.

Components

Overview list of all Tyler Forge components with names and summaries

Tyler Forge Installation

Complete installation guide for Tyler Forge web components

Tyler Forge Usage Guide

Comprehensive usage guide for Tyler Forge web components

Tyler Forge Angular Integration

Comprehensive framework-specific installation and usage instructions for Angular applications

Tyler Forge React Integration

Comprehensive framework-specific installation and usage instructions for React applications

Tyler Forge Vue Integration

Comprehensive framework-specific installation and usage instructions for Vue applications

Tyler Forge Svelte Integration

Comprehensive framework-specific installation and usage instructions for Svelte applications

Tyler Forge Lit Integration

Comprehensive framework-specific installation and usage instructions for Lit applications

Tyler Forge Icons

Complete guide to installing and using Tyler Forge icons in your application

Tyler Forge Design Tokens

Comprehensive Tyler Forge design tokens including colors, spacing, typography, animation, borders, elevation, layering, and shapes

Tyler Forge Color Design Tokens

Tyler Forge Design system color tokens, usage guidelines, and accessibility considerations

Tyler Forge Spacing Design Tokens

Tyler Forge Design system spacing tokens, usage guidelines, and best practices

Tyler Forge Animation Design Tokens

Tyler Forge Design system animation tokens, usage guidelines, and best practices

Tyler Forge Border Design Tokens

Tyler Forge Design system border tokens, usage guidelines, and best practices

Tyler Forge Elevation Design Tokens

Tyler Forge Design system elevation tokens, usage guidelines, and best practices

Tyler Forge Layering Design Tokens

Tyler Forge Design system layering tokens, usage guidelines, and best practices

Tyler Forge Shape Design Tokens

Tyler Forge Design system shape tokens, usage guidelines, and best practices

Tyler Forge Typography

Tyler Forge Design system typography guidelines and usage information

forge-accordion

Accordions wrap a collection of expansion panels to ensure that only one panel is expanded at a time.

forge-app-bar

App bars are headers used to display branding, navigation, and actions at the top of an application. They typically contain a logo, title, and various action items.

forge-app-bar-help-button

A help button component with a predefined help icon that displays a dropdown menu when clicked, designed for use in an app bar's end slot.

forge-app-bar-menu-button

A menu toggle button component with a predefined hamburger menu icon, typically used in an app bar's start slot to open navigation menus.

forge-app-bar-notification-button

A notification button component with a predefined notification bell icon that can display a badge with count or dot indicator, designed for use in app bars.

forge-app-bar-profile-button

A user profile button component that displays an avatar and opens a profile card popup with user information and action buttons when clicked.

forge-app-bar-search

A search input component with integrated search icon and styling optimized for use within app bars, supporting keyboard interaction and customizable actions.

forge-app-launcher

Documentation for forge-app-launcher component

forge-app-launcher-link

Documentation for forge-app-launcher-link component

forge-autocomplete

Autocomplete components provide real-time typeahead suggestions as users type in a text field. Use autocompletes to help users quickly find and select from a list of options, improving form usability and data accuracy.

forge-avatar

Avatars represent an entity via text or image. Use avatars to visually represent users, objects, or identifiers in your application.

forge-backdrop

Backdrops provide a semi-transparent overlay behind modal content like dialogs and drawers. These are building blocks for creating modal experiences, not intended to be used directly.

forge-badge

Badges display small amounts of non-interactive information like counts, status indicators, or notifications.

forge-banner

Banners are used to inform users of important information, such as errors, warnings, or success messages. Use banners for non-critical messages that require user attention but do not interrupt workflow.

forge-bottom-sheet

Bottom sheets slide up from the bottom of the screen to reveal more content and/or actions that the user can take.

forge-busy-indicator

Documentation for forge-busy-indicator component

forge-button

Buttons are used when a user needs to take an action. They can be used to trigger an action, navigate to a new location, and can be styled with a variety of themes and variants.

forge-button-area

Button areas are used to create clickable areas that group related information and actions about a single subject. The button area component wraps any arbitrary content with a `<button>` element to enable accessible, clickable interfaces including nested controls and other complex content.

forge-button-toggle

Button toggles allow users to select from a group of choices with single or multiple selection.

forge-button-toggle-group

Button toggle groups allow users to select one or more options from a set of button toggles.

forge-calendar

A flexible calendar component for date selection with support for single dates, ranges, multiple selections, and extensive customization options.

forge-card

Cards group related content and actions together in a single container.

forge-checkbox

Checkboxes select single values for submission in a form.

forge-chip

A compact, interactive element that represents an entity, action, or attribute with support for selection, removal, and various styling options.

forge-chip-field

A specialized input field component that allows users to create and manage a collection of chips representing text values or selections. Use a chip field when you want to allow users to input multiple discrete items, such as tags, categories, or selections from a predefined list. Prefer alternatives such as a select or autocomplete when dealing with a large number of options or when single selection is sufficient.

forge-chip-set

Chip sets are used to group multiple chips together and orchestrate their behavior.

forge-circular-progress

Circular progress indicators display progress by animating along a circular track in a clockwise direction. They can be used to represent both determinate and indeterminate progress.

forge-color-picker

An interactive color selection component with support for multiple color formats (hex, RGB, HSV) and optional opacity control. Intended to be used either inline, or within a popover or dialog for selecting colors.

forge-confirmation-dialog

Documentation for forge-confirmation-dialog component

forge-date-picker

A date input component with an integrated calendar popup for selecting single dates.

forge-date-range-picker

A date input component with integrated calendar popup for selecting date ranges with separate "from" and "to" date values.

forge-deprecated-button

Documentation for forge-deprecated-button component

forge-deprecated-icon-button

Documentation for forge-deprecated-icon-button component

forge-dialog

Dialogs are temporary UI elements that are used to display information, ask for input, or confirm actions. Dialogs can be modal or non-modal.

forge-divider

Dividers are used to separate elements with a thin line, either vertically or horizontally.

forge-drawer

A persistent side navigation drawer component that provides the ability to dismiss and open the drawer with smooth animations. Use for navigation or to display additional content alongside the main application content.

forge-expansion-panel

Expansion panels provide progressive disclosure of content.

forge-fab

Floating action buttons are used to represent the most important action on a page. They are typically used in mobile applications, and are positioned above other content in a way that draws attention to them.

forge-field

Documentation for forge-field component

forge-file-picker

The file picker component allows for a user to upload files of their own to the system. The component provides a slot for a button, as well as drag-and-drop functionality to launch the system file chooser dialog. There are visual cues to let the user know when files they are dragging can be dropped, as well as events that are relayed to the developer to handle files that are legal and/or illegal based on the parameters set on the component. The expectation of this component is that it will be used as a familiar element on the page that will let users upload files, while providing that visual and functional consistency.

forge-focus-indicator

Focus indicators show a "focus ring" around an attached element that matches `:focus-visible`. These are building block components used by other components to show focus state, and are not typically used directly.

forge-icon

Icons are used to represent information visually. The icon component is a wrapper around SVG icons that are registered in the icon registry.

forge-icon-button

Icon buttons are buttons that contain **only** an icon, and are used to represent actions or commands. Always provide an accessible label when using icon buttons.

forge-inline-message

Inline messages are used to provide feedback to the user about a specific action or state. Use inline messages to communicate information such as errors, warnings, or success messages in a way that is contextual to the content on the page.

forge-key

Keys present key items to label a chart or data visualization.

forge-key-item

Key items label a chart or data visualization.

forge-keyboard-shortcut

A utility component that listens for keyboard shortcut combinations and triggers callbacks or events when the specified key bindings are activated.

forge-label

The Label component is used to associate a text label with a compatible Forge component.

forge-label-value

Label values are used to display a label and value pair in a compact format with the proper typography and spacing styles applied.

forge-linear-progress

Linear progress indicators display progress by animating along a linear track in a horizontal direction. They can be used to show determinate or indeterminate progress.

forge-list

Lists are vertically oriented groups of related content that allow users to select or view one or more items from a set.

forge-list-item

List items are individual rows of content inside of a list.

forge-menu

Menus display a list of options or actions that users can select from a dropdown. Menus wrap button or list item elements to provide the trigger for displaying the menu options.

forge-meter

Meters display a scalar value within a defined range.

forge-meter-group

Meter groups display several meters together on one track.

forge-mini-drawer

A compact navigation drawer component that displays as a narrow rail and optionally expands on hover to show full content.

forge-modal-drawer

A modal navigation drawer component that slides in from the side with a backdrop overlay, typically used for temporary navigation panels. Prefer to use the dialog component with the preset options for sidesheet styles drawers.

forge-multi-select-header

Documentation for forge-multi-select-header component

forge-open-icon

Open icons are icons used to indicate whether a section is open or closed. They provide an animated transition between the two states to enhance the user experience.

forge-option

Options represent individual selectable items within `<forge-select>` components.

forge-option-group

Groups related options together with an optional label within select components.

forge-overlay

Overlays are used to show content in an element that is rendered above all other content on the page, and positioned around a specified anchor element. This is a low-level building block component that does not provide any visual styles, but is used within other components such as popovers, and tooltips.

forge-page-state

Page states display full-height messages for empty states, errors, or other general information. They can be used as full page content, or within smaller containers and will adapt accordingly.

forge-paginator

Paginators provide navigation controls for dividing content across multiple pages. Typically used alongside data tables or lists.

forge-popover

Popovers are used to show content in an element that is rendered above all other content on the page. Use popovers to display additional information or actions related to a specific element. Popovers are typically triggered by user interaction, such as clicking a button or hovering over an element.

forge-profile-card

Profile cards display user information and actions in a structured card format. This component is deprecated prefer using the `<forge-user-profile>` component from the extended library instead.

forge-profile-link

Documentation for forge-profile-link component

forge-quantity-field

Documentation for forge-quantity-field component

forge-radio

The Forge Radio component is used to create a form input where only one out of a set of values should be selected.

forge-radio-group

The Forge Radio Group component groups a set of radio buttons together.

forge-responsive-toolbar

Documentation for forge-responsive-toolbar component

forge-scaffold

The scaffold provides a generic layout structure for your content using common named areas. Use scaffolds for full page layouts or smaller sections within other elements where you want positioned content areas and scrollable body content.

forge-select

Select components are comboboxes that present a list of options to users for single or multi-selection.

forge-select-dropdown

A dropdown variant of the select component that renders options in a popover.

forge-skeleton

Skeletons are used to provide a placeholder for content that is loading. They have various styles to represent different types of content.

forge-skip-link

The Forge Skip Link component is used to provide an accessible way for users to skip repetitive content and navigate directly to a section of the page. This is used for screen reader and keyboard users to improve the overall accessibility of web applications.

forge-slider

Sliders allow users to make selections from a range of values. You can use sliders for selecting values from either a continuous or discrete range, and they can also be used for selecting a single value or a range of values.

forge-split-button

Split buttons are used for splitting an action into two parts, typically a primary action and a secondary action that opens a menu or performs an alternative action. Split buttons expect child Forge buttons as their content.

forge-split-view

Split views create resizable panels that allow users to adjust the space between content areas.

forge-split-view-panel

Individual panels within split views that can be resized and collapsed.

forge-stack

The stack is a utility component that helps manage spacing and alignment of immediate children along a vertical or horizontal axis. Use stacks sparingly to avoid unnecessary DOM complexity, and prefer CSS flexbox or grid for more complex layouts.

forge-state-layer

State layers show the interaction status of an element. These layers are semi-transparent overlays that indicate hover, focus, press, and drag states. State layers are building blocks for components and should generally not be used directly, but part of other components that have interactive states.

forge-step

Individual steps within a stepper component that represent progress in a multi-step process.

forge-stepper

Steppers guide users through multi-step processes by breaking them into logical steps.

forge-switch

Switches toggle the state of a single setting on or off.

forge-tab

Tab components represent a single tab inside a tab bar.

forge-tab-bar

Tab bars organize a set of tabs, holding selection state and enabling navigation between different views or sections of content.

forge-table

Tables are used to display sets of data. They organize information into rows and columns, making it easier to read, compare, and analyze. The Forge table provides a configuration-based approach to building data tables with means for sorting, filtering, selecting, and customizing the display of tabular data.

forge-text-field

The Forge Text Field component is an input field used to capture user text input. It requires a child `<input>` or `<textarea>` element to function properly, and an optional `<label>` element can be used to provide a label for the `<input>`.

forge-theme-toggle

Documentation for forge-theme-toggle component

forge-time-picker

A time input component with integrated dropdown for selecting time values with support for various formats, masking, and validation options.

forge-toast

Toasts are non-modal notifications that appear in response to user interactions. Use toasts to provide brief messages about app processes at the bottom or top of the screen. They automatically disappear after a timeout, but can also include an action button and a dismiss button.

forge-toolbar

Toolbars allow you to place titles and actions within a container and align them to the start, center, or end of the toolbar. This component is useful as headers and footers within pages, dialogs, sections... etc. to ensure consistent layout and alignment.

forge-tooltip

Tooltips display information related to an element when the user focuses or hovers over an anchor element. Use tooltips to provide additional context or information about elements that may not be immediately apparent.

forge-user-profile

Documentation for forge-user-profile component

forge-view

Represents a single view content area within a view-switcher for organizing and displaying content sections.

forge-view-switcher

A container component that manages switching between multiple child `<forge-view>` elements with configurable animations and programmatic navigation controls.

forge_mode

Activates forge mode with guardrails and rules to guide Tyler Forge tasks successfully

Related MCP Servers

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇