Peça a um agente de IA para “escrever o contrato de serviço para a Contoso” e ele o fará, com suas próprias palavras, com seus próprios cabeçalhos e com um total que calculou mentalmente. Essa é a divisão de trabalho errada. Com o GroupDocs.Assembly.Mcp em execução localmente (dnx GroupDocs.Assembly.Mcp --yes), Claude Desktop, Cursor ou Copilot perguntam ao seu modelo Word quais campos são necessários, preenchem‑nos a partir de suas notas, e o mecanismo renderiza o contrato, a tabela e a aritmética incluída, sem que o modelo toque no layout:

Crie o contrato de serviço para este pedido usando contract-template.docx e salve‑o como PDF: Contoso Pharma, Keizersgracht 210 Amsterdam, contato Dr. Lena Brandt; 12 meses de hospedagem gerenciada a 4,800 EUR, 12 meses de suporte a 1,200 EUR, um workshop de integração a 3,500 EUR; 5 por cento de desconto.

A versão passo a passo com configuração e solução de problemas está na documentação: Como gerar documentos a partir de modelos com agentes de IA usando MCP.

Por que o modelo não deve escrever o documento?

Porque um documento gerado falha de maneiras difíceis de perceber. O layout se afasta daquele aprovado legalmente. Uma cláusula é parafraseada para algo que soa bem, mas significa outra coisa. Um total surge a partir da predição do próximo token em vez de multiplicação. E cada execução é um pouco diferente, de modo que a revisão do mês passado não informa nada sobre o contrato deste mês.

Um modelo inverte isso. O departamento jurídico possui contract-template.docx, com seus cabeçalhos, seu bloco de assinatura e suas tags <<[customer.Name]>>. O trabalho do modelo reduz‑se à parte em que ele é bom: ler um e‑mail ou um conjunto de notas e transformá‑las em valores estruturados. O mecanismo faz o resto, da mesma forma a cada vez.

Como o agente sabe o que preencher?

Ele consulta o modelo. get_template_fields lê as tags sem executar o mecanismo e devolve os nomes que o modelo usa, cada campo que ele lê, e um esqueleto JSON a ser preenchido. Isto é o que o servidor retornou para o nosso modelo de contrato:

-> get_template_fields {"template":{"filePath":"contract-template.docx"}}
<- { "tagCount": 17,
     "dataSourceNames": [ "contract", "customer", "items" ],
     "dataSkeleton": {
       "contract": { "Number": "", "Date": "", "Discount": "" },
       "customer": { "Name": "", "Address": "", "Contact": "",
                     "Email": "" },
       "items": [ { "Title": "", "Quantity": 0, "UnitPrice": 0 } ] } }

Esse esqueleto é o contrato entre o modelo e o documento. O agente o preenche a partir do texto do pedido e o devolve como dataJson.

O que acontece quando o agente esquece um campo?

Ele é informado, precisamente. No nosso teste, a primeira tentativa do agente deixou de fora o endereço de e‑mail do cliente. O servidor recusou e apontou a lacuna:

-> assemble_document {"template":{...},"dataJson":"{... no Email ...}"}
<- Document assembly failed for 'contract-template.docx': ...
   Can not get the value of member 'Email' on type ''. The template
   reads 'Email', which the data does not have. Check the spelling
   (names are case-sensitive) with get_template_fields and add it to
   the data. ... pass allowMissingMembers=true to output nothing for
   missing members and empty lists.

Um modelo que escrevesse texto livre teria deixado a linha ausente silenciosamente. Aqui o agente pode pedir o endereço a você, ou decidir com você que o campo pode permanecer vazio.

Toda a troca

user            agent                       Assembly MCP server
 | "Make the contract for this order: ..."                      |
 |-------------->|                                              |
 |               |-- get_template_fields {"template":          |
 |               |     "contract-template.docx"} ------------->|
 |               |<- dataSkeleton: contract, customer, items --|
 |               |   (fills the skeleton from the order text)  |
 |               |-- assemble_document {"dataJson":"{...}",    |
 |               |     "format":"pdf"} ----------------------->|
 |               |<- Saved to: .../contract-template_          |
 |               |   assembled.pdf ----------------------------|
 |<- "Contract ready: 3 items, total 75500 EUR, 5% discount."  |
   layout, table and arithmetic come from the template

Com o e‑mail adicionado, a segunda chamada foi bem‑sucedida:

-> assemble_document {"template":{"filePath":"contract-template.docx"},
     "dataJson":"{...}","format":"pdf"}
<- Assembled 'contract-template.docx' with inline JSON (JSON object)
   as PDF
   Saved to: .../contract-template_assembled.pdf

O documento contém uma tabela de taxas de três linhas construída por um <<foreach>> na linha da tabela, valores calculados pelo modelo (<<[item.Quantity * item.UnitPrice]>>), um total de 75500 EUR a partir de items.Sum(...), e a linha “Um desconto de 5 por cento se aplica.”, que existe apenas porque uma tag <<if>> encontrou um desconto nos dados. O modelo não calculou nada disso.

Isso é melhor que um serviço de modelo hospedado?

É uma troca diferente. Serviços de modelo hospedado recebem seu modelo e dados via HTTPS, renderizam na nuvem e cobram por documento ou por crédito. Aqui o modelo, os dados e a saída permanecem em uma pasta na sua máquina; o mecanismo é o GroupDocs.Assembly em execução no processo, e nada escuta em uma porta. O que viaja para o provedor do seu modelo é o texto do pedido que você cola e o esqueleto que o agente preenche, não o contrato renderizado. A arquitetura está no post da família sobre processamento de documentos de IA on‑premise.

Limites honestos

  • Modo de avaliação: cada documento gerado começa com a linha “Evaluation Only. Created with GroupDocs.Assembly 26.7…”, planilhas salvas ganham uma planilha extra, e modelos de e‑mail mantêm apenas o corpo em texto simples. Um arquivo de licença ou chaves tarifadas removem os três.
  • A sintaxe do modelo é <<[name]>>. Marcadores {{name}} são deixados como texto; get_template_fields indica isso.
  • Modelos são entrada confiável: tags de imagem e documento carregam qualquer caminho ou URL que sua expressão retorne. Monte uma pasta para o servidor.
  • Datas: escreva‑as como 2026-11-12T00:00:00 e formate‑as no modelo (<<[contract.Date]:"d MMMM yyyy">>). Uma data apenas "2026-11-12" foi impressa como 11 de novembro em uma máquina UTC+2 no nosso teste.
  • O agente é a fonte de dados. Peça‑lhe que liste os valores que extraiu antes de renderizar, e revise‑os.

Perguntas Frequentes

Um agente de IA pode preencher meu modelo Word sem enviá‑lo?
Sim. O servidor roda localmente via stdio e lê o modelo da pasta que você configurar; a saída é gravada ao lado dele.

Em quais formatos o modelo pode estar?
Word, Excel, PowerPoint, Markdown, HTML, texto e modelos de e‑mail; cada um pode ser salvo em seu próprio formato ou em PDF e outros. get_supported_formats os lista por modelo.

E se o modelo for mantido por outra pessoa?
Esse é o ponto. Quem possui o modelo altera cláusulas e layout; o agente continua preenchendo o mesmo esqueleto, e get_template_fields mostra a ele qualquer novo campo na próxima vez que solicitar.

Aprofunde‑se