Alguien te entrega una plantilla de Word y una fecha límite. ¿Qué datos necesita? La respuesta habitual es abrirla, desplazarse, adivinar, ejecutarla, leer el error y volver a ejecutarla. Con GroupDocs.Assembly.Mcp ejecutándose localmente (dnx GroupDocs.Assembly.Mcp --yes), Claude Desktop, Cursor o Copilot consultan directamente la plantilla: get_template_fields devuelve cada etiqueta, los nombres de datos que usa y un esqueleto JSON para rellenar, sin ejecutar el motor, y cuando una ejecución falla, el error indica qué cambiar:

¿Qué datos necesita order-lines.docx? Si no se generará, dime por qué y cómo arreglar la plantilla.

La versión paso a paso con configuración y solución de problemas está en la documentación: Cómo averiguar qué necesita una plantilla y por qué falló.

¿Por qué inspeccionar antes de rellenar?

Porque prueba y error es la forma costosa de aprender un esquema. Un agente que adivina nombres de campos a partir del texto visible de un documento adivinará CustomerName cuando la plantilla lee customer.Name, y cada suposición errónea cuesta un viaje de ida y vuelta y un error confuso. Una plantilla no es prosa; es un programa con un contrato de datos, y el contrato puede leerse.

Eso es todo lo que hace get_template_fields. Analiza las etiquetas <<…>>, determina los nombres y construye el esqueleto:

-> get_template_fields {"template":{"filePath":"order-lines.docx"}}
<- { "tagCount": 3,
     "dataSourceNames": [ "lines" ],
     "fields": [ "lines[].Title", "lines[].Quantity" ],
     "dataSkeleton": { "lines": [ { "Title": "", "Quantity": "" } ] },
     "notes": [ "fields y dataSkeleton se infieren de las etiquetas, no del motor; los valores calculados por proyecciones Select/GroupBy no se siguen." ] }

La nota es honesta sobre el método: esta es una inspección estática. Un field producido dentro de una proyección Select no se sigue. Para un contrato normal, carta o plantilla de factura, el esqueleto es exactamente lo que hay que rellenar.

El esqueleto también cambia la conversación contigo. En lugar de “Intenté generar el pedido y falló”, el agente puede decir “esta plantilla necesita una lista de líneas, cada una con un título y una cantidad; encontré tres en tu correo, aquí están”, y solo entonces generar. La inspección es barata, no necesita datos y no toca nada, por lo que es la primera llamada correcta para cualquier plantilla que el agente no haya visto antes, y la llamada correcta nuevamente siempre que alguien haya editado la plantilla desde entonces.

Tres fallos, tres respuestas

problema de plantilla          qué dice el servidor          la solución
------------------------  ----------------------------  -------------------
{{name}} placeholders     "2 '{{...}}' placeholder(s).  write <<[name]>>
                          ... does not process that
                          syntax"
<<foreach>> never closed  "Unexpected end of template.  add <</foreach>>
                          A block tag is not closed"
data lacks a field        "The template reads 'Email',  add it, or
                          which the data does not have" allowMissingMembers

La sintaxis incorrecta. Muchísimas plantillas en la naturaleza fueron escritas para otros motores y usan {{name}}. GroupDocs.Assembly deja esas como texto, y la inspección lo indica antes de que alguien desperdicie una ejecución:

-> get_template_fields {"template":{"filePath":"shipping-notice.docx"}}
<- { "tagCount": 0, "notes": [ "No <<…>> tags were found: ...",
     "The template contains 2 '{{…}}' placeholder(s). GroupDocs.Assembly
      does not process that syntax and leaves it as text; write
      <<[name]>> instead." ] }

El bloque sin cerrar. Nuestra order-lines.docx abre un <<foreach>> y nunca lo cierra. La inspección lista las etiquetas felizmente; la generación no:

-> assemble_document {"template":{"filePath":"order-lines.docx"},
     "dataJson":"{\"lines\":[{\"Title\":\"Cable\",\"Quantity\":2}]}"}
<- Document assembly failed for 'order-lines.docx': ...
   Unexpected end of template. A block tag is not closed: every
   <<foreach>> needs <</foreach>> and every <<if>> needs <</if>>.

El campo faltante. Cuando los datos carecen de algo que la plantilla lee, el error nombra el campo, indica que los nombres distinguen mayúsculas y minúsculas y ofrece el interruptor: allowMissingMembers: true no produce salida para miembros faltantes y devuelve listas vacías en lugar de fallar. Esa pista es más amplia que el motor, como muestra la siguiente sección: una lista vacía sigue fallando cuando la plantilla realiza operaciones aritméticas con sus miembros.

Cuando la plantilla está llena de errores

Algunas plantillas tienen varios errores, y corregirlos una ejecución fallida a la vez es lento. inlineErrors: true convierte la plantilla en su propio informe de errores: el documento se genera y cada etiqueta defectuosa recibe su mensaje escrito al lado. En la plantilla de ejemplo de los ejemplos de GroupDocs.Assembly:

-> assemble_document {"template":{"filePath":"inline-error.docx"},
     "dataJson":"{\"name\":\"x\"}","inlineErrors":true}
<- Assembled 'inline-error.docx' ... The template has errors: each one
   is written into the output next to its tag, starting with 'Error!'

La salida contiene << var [name] Error! An assignment operator is expected. >>, en el lugar del documento donde está la etiqueta. Abre el archivo, corrige cada etiqueta marcada, vuelve a ejecutar sin la bandera.

Lo que la inspección no puede ver

Las plantillas binarias de Outlook son la excepción. Las etiquetas de un archivo .msg no pueden leerse sin generarlo, y el servidor lo indica en lugar de devolver una lista vacía que parece “no hay campos”:

-> get_template_fields {"template":{"filePath":"contracts-table.msg"}}
<- { "readable": false, "notes": [ "Tags cannot be read from a .msg
     template without generating it. Save the template as DOCX, XLSX,
     PPTX or EML to inspect it, or generate it with assemble_document
     and inlineErrors=true to see which fields fail." ] }

Otra trampa que encontramos: una lista vacía en los datos no tiene tipos de miembros. Nuestra plantilla de contrato multiplica item.Quantity * item.UnitPrice; con "items": [] y allowMissingMembers: true, la generación aún fallaba con “Can not apply operator ‘’ to operands of type ‘System.Object’ and ‘System.Object’”*. La guardia obvia, <<if [items.Any()]>> alrededor de la tabla, no ayudó: el motor verifica cada expresión antes de ejecutar cualquier cosa. Lo que funcionó fue mantener la aritmética fuera de la fila. Con la cantidad ya en los datos (<<[item.Amount]>>), la misma lista vacía y allowMissingMembers: true produjeron el documento, y <<if [items.Count() == 0]>>No services ordered.<</if>> imprimió su línea. De lo contrario, haz que el agente verifique que una lista no esté vacía antes de generar, y pregúntale cómo debería verse un contrato vacío.

Límites honestos

  • La inspección es estática: las proyecciones Select y GroupBy no se siguen, y las plantillas .msg no pueden leerse.
  • Las plantillas son entrada confiable; las etiquetas de imagen y documento cargan las rutas y URLs que devuelven sus expresiones.
  • Modo de evaluación: cada salida comienza con “Evaluation Only. Created with GroupDocs.Assembly 26.7…”.
  • Fechas: pasa 2026-11-12T00:00:00 y formatea en la plantilla con :"d MMMM yyyy"; una cadena solo de fecha se desplazó un día en una máquina UTC+2, y "12.11.2026" se interpretó como 11 de diciembre.

FAQ

¿Cómo puedo ver qué campos necesita una plantilla de Word?
Pide al agente que llame a get_template_fields sobre ella. Obtienes las etiquetas, los nombres de datos y un esqueleto JSON, localmente, sin generar nada.

¿Por qué mi plantilla imprime {{name}} en lugar del valor?
Porque las etiquetas de GroupDocs.Assembly son <<[name]>>. La inspección del servidor marca los marcadores {{…}} y dice qué escribir en su lugar.

¿Puede Markdown ser una plantilla?
Sí. Nuestro product-readme.md con etiquetas <<[product]>> y <<[description]>> se inspeccionó como un archivo Word y se generó directamente a DOCX.

Profundizar