GroupDocs.Assembly MCP Server Leave feedback

GroupDocs.Assembly MCP server lets AI agents like Claude, Cursor, and Copilot generate documents from templates and data — a contract from a JSON object, a letter per customer, a report with tables and charts from a CSV — in Word, Excel, PowerPoint, PDF and email, locally on your machine. The agent supplies the data; the template controls the document.

Run it with one command. The Docker image is self-contained — the runtime and every native dependency the engine needs are inside it:

docker run --rm -i -v $(pwd)/documents:/data \
  ghcr.io/groupdocs-assembly/assembly-net-mcp:latest

With the .NET 10 SDK installed, the same server also runs without Docker:

dnx GroupDocs.Assembly.Mcp --yes

Both are the .NET build of the server and run on Windows, Linux, and macOS. Other platforms will each get their own launcher — see Install for your platform.

Or use the guided installer to register the server in your AI client, verify the setup, and configure shared folders in one pass.

Then ask your agent, in plain language:

What data does contract-template.docx need? Fill it for Contoso Pharma with the three services below and save it as a PDF.

Six tools (full details in the tools reference):

The pattern behind every scenario — captured from the server:

user              agent                        Assembly MCP server
 |  "Make the contract for this order: Contoso Pharma, 12 months ..."  |
 |---------------->|                                                   |
 |                 |-- get_template_fields ------------------------->|
 |                 |   {"template":{"filePath":                        |
 |                 |     "contract-template.docx"}}                    |
 |                 |<- {"dataSourceNames":["contract","customer",      |
 |                 |    "items"], "dataSkeleton":{"customer":{"Name":  |
 |                 |    ""...}, "items":[{"Title":"","Quantity":0}]}} -|
 |                 |   the agent fills the skeleton from the order     |
 |                 |-- assemble_document --------------------------->|
 |                 |   {"template":{...},"dataJson":"{...}",           |
 |                 |    "format":"pdf"}                                |
 |                 |<- "Assembled 'contract-template.docx' with inline |
 |                 |    JSON (JSON object) as PDF" --------------------|
 |<- "Contract SA-2026-118 is ready: 3 services, total 75500 EUR."     |
   the model writes the data; layout, tables and wording come from the template

The model never composes the document. It reads the template’s data contract — the skeleton from get_template_fields — and fills it; the engine renders tables, totals, conditional paragraphs, charts, images and barcodes exactly as the template defines them. The same data gives the same document every time, and a reviewer checks a JSON object instead of re-reading prose.

data you give            what the template sees               how to name it
-----------------------  -----------------------------------  ----------------
JSON object              its keys: contract, customer, items  nothing to do
JSON array / XML / CSV   one collection                       worked out from
spreadsheet / Word table   (columns are the members)            the template, or
                                                                dataSourceName
"2026-11-12T00:00:00"    a date - format it in the template   :"d MMMM yyyy"
{{name}} in a template   left as text - not Assembly syntax   use <<[name]>>

JSON (inline or a file), XML, CSV and the tables of Excel, Word and PowerPoint documents all work. Details and the template language in one table: tools reference.

• Generate documents with AI agents — start here: template → skeleton → document.
• One document per record (mail merge) — a letter per customer, named after the customer.
• Reports with tables and charts from data files — a spreadsheet or CSV in, a report out.
• Inspect and fix a template — what it needs, and why it failed.
• Build a document from data the agent extracted — from an email or notes to a finished contract.
• Generate reports from repository data — release notes and certificates with Claude Code.
• On-premise architecture — what stays local, and what a template can reach.

Installation, prerequisites, and client configuration are platform-specific; the tools and licensing model are the same everywhere.

Exact config blocks for every client: Register in AI clients.

The server uses MCP’s local stdio transport: your AI client starts the server as a child process and talks to it over standard input/output. No inbound ports, no external endpoints, no telemetry — the data path is agent → local server → local filesystem. Templates and data are read from your storage folder; generated documents are written next to them. Details: On-premise architecture.

• Quick start · Use cases · Supported formats · Troubleshooting & FAQ
• GitHub: server source · installer · integration tests
• NuGet package · Docker image · MCP Registry
• The library behind it: GroupDocs.Assembly for .NET and its template syntax
• Questions: Assembly forum