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
SelectyGroupByno se siguen, y las plantillas.msgno 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:00y 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
- Documentación, guía canónica: Cómo averiguar qué necesita una plantilla y por qué falló
- Centro de documentación: Servidor GroupDocs.Assembly MCP
- Página del producto GroupDocs.Assembly MCP — instalación con un clic para VS Code y Cursor, configuraciones para cualquier otro cliente
- Empieza aquí: Deja que el modelo rellene los datos, no que escriba el documento
- Relacionado: Cien PDFs personalizados a partir de un prompt: combinación de correspondencia con un agente de IA
- Relacionado: El gráfico proviene de la plantilla, los números provienen de los datos
- Relacionado: Tu repositorio ya tiene los datos; deja que el agente genere el PDF
- On‑premise y modelo de seguridad: 3 arquitecturas para el procesamiento de documentos con IA, y la que mantiene los archivos dentro de tu red
- Preguntas: Foro de GroupDocs Assembly
- Fuente: GroupDocs.Assembly.Mcp en GitHub