Skip to main content
Glama
backsoul

Dynamic Form MCP

by backsoul
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Local

Dynamic Form MCP (Model Context Protocol)

Este documento describe cómo utilizar el servidor MCP (Model Context Protocol) para la gestión de formularios dinámicos. El servidor expone herramientas para crear, obtener y gestionar las respuestas de formularios dinámicos utilizando la librería @dynamicfrm/js. Este servidor está diseñado para ser utilizado con un cliente MCP, como el Inspector MCP integrado en Visual Studio Code.

Prerrequisitos

Asegúrate de tener Node.js y npm (o yarn) instalados en tu sistema. También se asume que tienes Visual Studio Code instalado y la extensión del Inspector MCP habilitada.

Related MCP server: SupaUI MCP Server

Instalación y Construcción

  1. Clona o descarga este repositorio (si aplica).

  2. Navega al directorio del proyecto en tu terminal.

  3. Instala las dependencias necesarias:

    npm install
# o
yarn add

    Esto instalará las siguientes dependencias principales utilizadas en el servidor:

    • @modelcontextprotocol/sdk/server/mcp.js: Para la creación del servidor MCP.

    • @modelcontextprotocol/sdk/server/stdio.js: Para el transporte estándar de entrada/salida del servidor MCP.

    • zod: Para la validación de los datos de entrada de las herramientas.

    • uuid: Para la generación de UUIDs únicos para los formularios.

    • @dynamicfrm/js: La librería principal para la creación y gestión de formularios dinámicos.

  4. Construye el proyecto:

    npm run build

    Este comando generará los archivos necesarios en el directorio de construcción (build), incluyendo el archivo principal del servidor (index.js).

Configuración en Visual Studio Code para el Inspector MCP

Para que el Inspector MCP de VS Code descubra y pueda interactuar con este servidor, necesitas configurar la sección mcp en la configuración de VS Code (settings.json). Un ejemplo de configuración sería:

{
  "chat.mcp.discovery.enabled": true,
  "mcp": {
    "inputs": [],
    "servers": {
      "dynamicform": {
        "command": "node",
        "args": [
          "/ruta/absoluta/a/tu/proyecto/build/index.js"
        ]
      }
    }
  }
}

Importante: Reemplaza /ruta/absoluta/a/tu/proyecto/build/index.js con la ruta absoluta real a tu archivo index.js construido.

Ejecución a través del Inspector MCP de VS Code

Una vez configurado, el Inspector MCP de VS Code debería detectar automáticamente el servicio dynamicform. Podrás interactuar con las herramientas expuestas por el servidor directamente desde la interfaz del Inspector.

Para interactuar con las herramientas:

  1. Abre el Inspector MCP en VS Code (generalmente a través de la paleta de comandos o en la barra lateral).

  2. Busca el servicio dynamicform.

  3. Selecciona la herramienta que deseas utilizar (por ejemplo, create-form).

  4. Proporciona los parámetros de entrada requeridos en formato JSON en el panel de entrada del Inspector.

  5. Ejecuta la herramienta.

  6. La respuesta del servidor se mostrará en el panel de resultados del Inspector.

Herramientas Disponibles

El servidor MCP de formularios dinámicos expone las siguientes herramientas, que puedes invocar a través del Inspector MCP:

create-form

Descripción: Crea un nuevo formulario dinámico con campos personalizados.

Parámetros:

{
  title: z.string().min(3).describe('Título del formulario'),
  fields: z
    .array(
      z.object({
        type: z.string().describe('Tipo de campo (e.g., text-field, list-field)'),
        name: z.string().describe('Nombre del campo'),
        label: z.string().optional().describe('Etiqueta para mostrar en el formulario'),
        placeholder: z.string().optional().describe('Texto de marcador de posición'),
        required: z.boolean().optional().describe('Indica si el campo es obligatorio'),
        options: z.array(z.string()).optional().describe('Opciones para campos de lista'),
        url: z.string().optional().describe('URL para campos como qr-field o yt-video'),
        email: z.string().optional().describe('Correo electrónico para email-field'),
        subject: z.string().optional().describe('Asunto para email-field'),
        minLength: z.number().optional().describe('Longitud mínima para campos de texto'),
        maxLength: z.number().optional().describe('Longitud máxima para campos de texto'),
        pattern: z.string().optional().describe('Patrón de validación para campos de texto'),
        defaultValue: z.string().optional().describe('Valor por defecto del campo'),
      })
    )
    .min(1)
    .describe('Lista de campos del formulario'),
}

Ejemplo de uso (a través del Inspector MCP):

{
  "title": "Formulario de Contacto",
  "fields": [
    {
      "type": "text-field",
      "name": "nombre",
      "label": "Nombre",
      "required": true
    },
    {
      "type": "email-field",
      "name": "correo",
      "label": "Correo Electrónico",
      "required": true
    },
    {
      "type": "text-area",
      "name": "mensaje",
      "label": "Mensaje"
    }
  ]
}

Respuesta:

En caso de éxito, la respuesta contendrá la URL del formulario creado:

{
  "content": [
    {
      "type": "text",
      "text": "Formulario creado exitosamente: <URL_DEL_FORMULARIO>"
    }
  ]
}

En caso de error, la respuesta indicará el problema:

{
  "content": [
    {
      "type": "text",
      "text": "Ha ocurrido un error: <mensaje_de_error>"
    }
  ]
}

Available Tools

4 tools
create-answersC

Agrega múltiples respuestas a uno o varios formularios mediante sus UUID y los índices de campo

ParametersJSON Schema
NameRequiredDescriptionDefault
answersYesArray de respuestas a crear

TDQS

C2.9/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 full burden. It discloses the tool adds answers (a write operation) but lacks behavioral details like permission requirements, whether answers are editable after creation, rate limits, error handling, or what happens on success. For a mutation tool with zero annotation coverage, this is a significant 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, efficient sentence in Spanish that front-loads the key action and parameters. It wastes no words and 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.

Completeness2/5

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

Given no annotations and no output schema, the description is incomplete for a mutation tool. It doesn't explain what the tool returns, error conditions, or behavioral traits like idempotency. While the schema covers inputs well, the overall context lacks necessary operational details.

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 the schema fully documents the single parameter 'answers' and its nested structure (UUIDs, field indices, values). The description adds minimal semantics by mentioning UUIDs and field indices, but doesn't clarify format or constraints beyond what the schema provides. Baseline 3 is appropriate when schema does the heavy lifting.

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

Purpose4/5

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

The description clearly states the action ('Agrega múltiples respuestas') and the target resource ('a uno o varios formularios'), with specific identifiers ('mediante sus UUID y los índices de campo'). It distinguishes from siblings like 'create-form' (which creates forms) and 'get-answers' (which retrieves answers). However, it doesn't explicitly contrast with 'get-form', though the verb 'Agrega' implies creation versus retrieval.

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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., existing forms), exclusions (e.g., invalid UUIDs), or comparisons to siblings like 'get-answers' for reading answers. Usage is implied by the action but not explicitly stated.

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

create-formC

Crea un formulario dinámico con campos personalizados

ParametersJSON Schema
NameRequiredDescriptionDefault
titleYesTítulo del formulario
fieldsYesLista de campos del formulario

TDQS

C2.9/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 of behavioral disclosure. While 'Crea' implies a write/mutation operation, the description doesn't disclose important behavioral traits: what permissions are needed, whether the form becomes immediately available, what happens on failure, if there are rate limits, or what the return value looks like. For a creation tool with zero annotation coverage, this is a significant 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, efficient sentence in Spanish that clearly states the tool's purpose without any wasted words. It's appropriately sized and front-loaded with the essential information about what the tool does.

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?

For a creation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after creation, what permissions are required, error conditions, or the structure of the response. The description alone doesn't provide enough context for an agent to understand the full implications of using this 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 description coverage is 100%, so the schema already documents both parameters ('title' and 'fields') comprehensively with detailed field specifications. The description adds no parameter-specific information beyond what's in the schema. The baseline score of 3 is appropriate when the schema does the heavy lifting, even though the description doesn't add value beyond the schema.

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

Purpose4/5

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

The description clearly states the action ('Crea' - creates) and resource ('un formulario dinámico con campos personalizados' - a dynamic form with custom fields). It specifies the type of form being created (dynamic with custom fields), which is reasonably specific. However, it doesn't explicitly differentiate from sibling tools like 'get-form' or 'create-answers'.

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?

The description provides no guidance on when to use this tool versus alternatives. There are sibling tools like 'get-form' (likely for retrieving forms) and 'create-answers' (likely for submitting form responses), but the description doesn't mention these alternatives or provide context about when this creation tool is appropriate versus other operations.

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

get-answersB

Obtiene las respuestas de un formulario existente mediante su UUID

ParametersJSON Schema
NameRequiredDescriptionDefault
uuidYesUUID del formulario

TDQS

B3.1/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 of behavioral disclosure. It states it retrieves answers from an existing form via UUID, implying a read-only operation, but doesn't clarify permissions needed, error handling (e.g., invalid UUID), rate limits, or what the return format looks like (e.g., structured data). For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.

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, efficient sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, with every part contributing to understanding the action and resource. There is zero waste, making it highly concise and well-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?

Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks details on usage guidelines, behavioral traits, and output expectations. Without annotations or an output schema, the description should do more to compensate, but it meets a bare minimum for a simple read operation.

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 schema description coverage is 100%, with the single parameter 'uuid' fully documented in the schema as 'UUID del formulario'. The description adds no additional meaning beyond this, as it only references the UUID without explaining its format or source. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't need to given the schema's completeness.

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

Purpose4/5

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

The description clearly states the action ('obtiene las respuestas' - gets answers) and the resource ('de un formulario existente' - from an existing form), using a specific verb and target. It distinguishes from siblings like 'get-form' by specifying it retrieves answers rather than the form itself. However, it doesn't explicitly differentiate from 'create-answers' beyond the verb difference.

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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid UUID), exclusions, or comparisons to sibling tools like 'get-form' (which might retrieve form structure) or 'create-answers' (which creates answers). Usage is implied through the verb 'obtiene' but not explicitly defined.

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

get-formC

Obtiene la estructura de un formulario existente mediante su UUID

ParametersJSON Schema
NameRequiredDescriptionDefault
uuidYesUUID del formulario

TDQS

C2.9/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 of behavioral disclosure. It states this retrieves form structure, implying a read-only operation, but doesn't clarify permissions needed, rate limits, error handling, or what 'estructura' entails (e.g., fields, metadata). For a tool with no annotation coverage, this leaves significant behavioral gaps unaddressed.

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, efficient sentence that directly states the tool's function. It is front-loaded with the core action and resource, with no wasted words. However, it could be slightly more structured by explicitly separating purpose from constraints, but it remains appropriately concise for a simple retrieval tool.

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 the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'estructura' includes (e.g., fields, validation rules), potential errors, or the return format. For a tool with no structured behavioral or output documentation, the description should provide more context to compensate, which it fails to do adequately.

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% description coverage, with the 'uuid' parameter fully documented as 'UUID del formulario'. The description adds no additional semantic context beyond this, such as where to find the UUID or format specifics. With high schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.

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

Purpose4/5

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

The description clearly states the action ('obtiene' - gets/retrieves) and the resource ('estructura de un formulario existente' - structure of an existing form), making the purpose understandable. It doesn't explicitly differentiate from sibling tools like 'get-answers' or 'create-form', but the focus on form structure is reasonably distinct. The description avoids tautology by specifying what is retrieved rather than just restating the name.

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?

The description provides no guidance on when to use this tool versus alternatives like 'get-answers' or 'create-form'. It mentions the UUID requirement, but this is already covered in the input schema. There are no explicit instructions on prerequisites, error conditions, or appropriate contexts for selecting this tool over others.

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.

  1. 4 tool updates
    • First observedcreate-answers
    • First observedcreate-form
    • First observedget-answers
    • First observedget-form
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.5/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose: create-form and get-form handle form structure, while create-answers and get-answers handle form responses. There is no overlap in functionality, making it easy for an agent to select the correct tool based on the desired action (create vs. get) and target (form vs. answers).

Naming Consistency5/5

All tool names follow a consistent verb-noun pattern with hyphens (e.g., create-answers, get-form). The verbs 'create' and 'get' are used predictably across the set, and the nouns 'form' and 'answers' clearly indicate the resource type, ensuring readability and predictability.

Tool Count5/5

With 4 tools, this server is well-scoped for managing dynamic forms, covering both form creation/retrieval and answer submission/retrieval. Each tool earns its place by addressing a core aspect of the domain without being overly sparse or bloated.

Completeness4/5

The tool set provides complete CRUD coverage for forms (create and get) and answers (create and get), with no dead ends for basic workflows. A minor gap exists in missing update or delete operations for forms and answers, which agents might need to work around, but core functionality is well-covered.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

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

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

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/backsoul/dynamicform-mcp'

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