4,500+ servers built on MCP Fusion
Vinkius

HotDocs MCP. Automate complex document assembly from natural language prompts.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

HotDocs MCP on Cursor AI Code Editor MCP Client HotDocs MCP on Claude Desktop App MCP Integration HotDocs MCP on OpenAI Agents SDK MCP Compatible HotDocs MCP on Visual Studio Code MCP Extension Client HotDocs MCP on GitHub Copilot AI Agent MCP Integration HotDocs MCP on Google Gemini AI MCP Integration HotDocs MCP on Lovable AI Development MCP Client HotDocs MCP on Mistral AI Agents MCP Compatible HotDocs MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

HotDocs Advance connects your AI agent directly to document assembly workflows. It lets you list templates, initiate data interviews, and generate finalized documents—PDFs, Word docs, etc.—all via natural conversation.

No manual UI clicks required.

What your AI agents can do

Complete assembly

Generates the final documents (PDFs, Word docs) using all collected data for a specific work item version.

Create interview session

Starts an interactive session that collects answers needed for document variables before assembly can happen.

Create work item

Establishes a unique record in the system, linking it to a specific template package and ID.

+ 11 more capabilities included
Discover available templates

The agent lists all template packages and their versions in your account using list_template_packages.

Create structured work records

You create a new, unique work item record using create_work_item, which serves as the reference point for all subsequent data and documents.

Run interactive data interviews

The agent starts an interview session via create_interview_session to guide your client through collecting specific answers needed for the template variables.

Batch update document data

You inject bulk answers into a work item using XML format with update_answers, skipping interactive input when you already have the data.

Generate final documents

The agent triggers the full assembly process by calling complete_assembly to generate all necessary document files.

Audit incomplete submissions

You check for gaps using get_unanswered_variables to identify which required fields were left blank before final assembly.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

HotDocs MCP Server: 14 Tools for Document Automation

Use these tools to manage the entire lifecycle of structured document creation—from template discovery and data collection to final assembly and retrieval.

complete019d75b3

complete assembly

Generates the final documents (PDFs, Word docs) using all collected data for a specific work item version.

create019d75b3

create interview session

Starts an interactive session that collects answers needed for document variables before assembly can happen.

create019d75b3

create work item

Establishes a unique record in the system, linking it to a specific template package and ID.

get019d75b3

get auth token

Retrieves an up-to-date API access token. Use this if other tools fail with authentication errors.

get019d75b3

get document content

Downloads the actual content of a generated document using its unique ID after assembly is complete.

get019d75b3

get template package

Retrieves structural details for a specific template package ID, helping you understand its requirements before use.

get019d75b3

get unanswered variables

Checks a document to list any variables that were required by the template but never received an answer.

get019d75b3

get work item

Fetches all data associated with one specific work item ID at any point in the workflow.

list019d75b3

list documents

Lists all generated documents for a given work item, providing their file IDs and metadata.

list019d75b3

list template packages

Retrieves a list of every template package available in your account to determine what can be assembled.

list019d75b3

list template versions

Lists the version history for any specific template package ID.

list019d75b3

list work items

Finds work items using optional filters like user IDs or date ranges, useful for auditing records.

list019d75b3

list work items by date

Lists all work items that fall within a specific start and end date range (ISO 8601 format).

update019d75b3

update answers

Bulk updates the answers for a work item using a structured XML payload, useful when data comes from an external source.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

  • Import from OpenAPI, Swagger, or YAML specs
  • Create Agent Skills with progressive disclosure
  • Deploy to edge with MCPFusion framework
  • Built in DLP, auth, and compliance on every call
  • Real time usage dashboard and cost metering
  • Publish to catalog or keep private
Start building

Make Your AI Do More

Start with HotDocs, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ others, all in one place
  • Add new capabilities to your AI anytime you want
  • Every connection is secured and compliant automatically
  • Track usage and costs across all your servers
  • Works with Claude, ChatGPT, Cursor, and more
  • New servers added to the catalog every week

What you can do with this MCP connector

You connect your AI agent directly to document assembly workflows using HotDocs Advance. It lets you manage complex contract creation and reporting without ever clicking through a web interface. Your agent handles the whole process—from figuring out what documents exist, collecting all necessary data, generating the final file, and even auditing incomplete submissions.

Your agent first uses list_template_packages to check every template package available in your account, letting you determine exactly what kind of document structures can be assembled. You can then run list_template_versions on a specific package ID to see its full version history. If you need to find out the structural details of a particular template package, calling get_template_package gives you that info before you start.

Once you know what you're working with, your agent needs a reference point. It uses create_work_item to establish a unique record in the system, linking everything to a specific template package and ID. You can find existing records using list_work_items, which lets you filter by user IDs or date ranges, or narrow it down even more by calling list_work_items_by_date with an ISO 8601 start and end date format.

If you need to pull all the raw data associated with one of those work items at any point in time, get_work_item fetches that complete record.

When it comes to gathering information for a document, your agent has two main options. It can kick off an interactive session using create_interview_session, which guides your client through answering the specific variables needed for the template. If you already have all the data—say, if it's coming from another system—you don't need to talk to anyone; instead, you inject bulk answers into a work item by calling update_answers with a structured XML payload.

If there’s any chance that variables were missed during collection, your agent doesn't guess. It checks for gaps using get_unanswered_variables, listing every required field from the template that never got an answer. Once you confirm all data is ready and complete, calling complete_assembly generates the final documents—PDFs or Word docs—using all the collected data for a specific work item version.

The generated files are managed by other tools. You can see every document created for a particular work item by running list_documents, which gives you their file IDs and metadata. To actually get the content of that finished file, your agent uses get_document_content with the unique ID after assembly is complete.

If you need to check what documents were generated before calling list_documents, you can use it on a specific work item ID.

For troubleshooting or auditing purposes, there are other functions. You can retrieve an up-to-date API access token using get_auth_token if any of the other tools fail with authentication errors. Additionally, when generating documents, calling list_documents gives you the metadata and file IDs for all generated files associated with a given work item.

How HotDocs MCP Works

  1. 1 First, the agent calls create_work_item, giving it a unique ID and selecting the template package.
  2. 2 Next, the agent can run an interview via create_interview_session or inject data directly using update_answers. Once all variables are populated, the agent triggers complete_assembly.
  3. 3 The final step is calling list_documents to find the generated file ID, and then running get_document_content to download the finished PDF or Word document.

The bottom line is: You move from a raw template structure to a completed, downloadable document in three clear steps managed by your AI agent.

Who Is HotDocs MCP For?

This server is for legal teams, HR departments, and financial services that process standardized documents constantly. If you spend time opening templates, copy-pasting data from spreadsheets, or manually saving drafts—you need this. Your AI agent takes over the entire document lifecycle.

Legal Counsel

Generating contracts and agreements. Instead of manually filling out clauses for every new client, your agent reads the case details in natural language and generates a fully compliant contract.

HR Specialist

Handling employee onboarding and offboarding. The agent automatically creates employment contracts or policy acknowledgments using pre-approved templates at scale.

Compliance Officer

Running compliance checks across multiple employees. You can use list_work_items_by_date to find all submissions in a quarter and check for gaps with get_unanswered_variables.

What Changes When You Connect

  • Stop manually checking submissions. Use get_unanswered_variables to instantly audit a work item and see exactly which fields are missing before you run the final assembly.
  • Never rebuild workflows. You can discover every available template structure by calling list_template_packages, giving your agent full knowledge of your document library.
  • Process data in bulk, not piece-by-piece. Instead of clicking through forms, use update_answers with XML to inject all necessary data from a spreadsheet directly into the work item.
  • Get the final file immediately. After assembly completes via complete_assembly, you just call list_documents and then get_document_content to download the ready-to-use PDF or Word file.
  • Track everything across teams. You can find specific records using list_work_items_by_date or narrow down searches by user ID with list_work_items, making compliance auditing simple.

Real-World Use Cases

01

New client onboarding (Financial Services)

A compliance officer needs to assemble a loan application package. They first use list_template_packages to find the correct template ID. Then, they gather all required data points and run create_work_item. Finally, they call complete_assembly, getting the full set of legal documents ready for signature.

02

Annual HR policy distribution

HR needs to generate 50 offer letters. Instead of opening 50 templates and filling 50 times, they use update_answers in a loop, batch-injecting all the employee data (name, salary, start date) into the work item for immediate assembly.

03

Legal contract review audit

A legal team needs to check if any historical contracts are missing required clauses. They use list_work_items and then run get_unanswered_variables. The agent immediately flags which records need manual attention for compliance.

04

Post-meeting data capture (Operations)

An operations manager gathers notes after a client meeting. Instead of typing everything into the UI, they instruct their agent to create_interview_session, guiding them through the necessary variables one by one, ensuring no critical piece of info is missed before final assembly.

The Tradeoffs

Assuming a simple data dump works.

The user tries to call get_document_content right after running create_work_item, expecting the document to already exist and be downloadable.

You must follow the full sequence. Start by creating the work item (create_work_item), then collect data (via interview or update_answers), and only then run complete_assembly. The final download step requires calling list_documents first.

Relying on random IDs.

The user tries to update answers by passing a generic ID, like 'contract-draft'. This fails because the system needs a unique reference point for every document cycle.

Always start with create_work_item. The resulting alphanumeric identifier is your single source of truth. Use that specific work item ID when calling any other related tools (get_work_item, update_answers, etc.).

Forgetting the XML format.

When trying to batch update data, the user passes a simple JSON object or key-value pair into update_answers and gets an error.

The update_answers tool requires the answer payload to be in valid HotDocs Answer XML format. Ensure your input strictly follows the <AnswerSet> structure.

When It Fits, When It Doesn't

Use this server if your documents are highly standardized and based on predefined templates (e.g., contracts, policy letters, loan applications). The system is built for controlled, structured document assembly.

Don't use it if you need to write free-form reports or articles where the structure changes page-to-page. For those scenarios, a general text generation model might be better. If your goal is simply data storage and retrieval without template mapping, look into basic database connectors instead of document assemblers.

If you have structured templates but need to manage multiple versions (e.g., compliance updates), use list_template_versions early in your workflow. When the process needs human intervention or approval before generating content, consider adding a dedicated state machine layer outside of these tools.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by HotDocs Advance. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

How we secure it →

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This server provides 14 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

complete_assembly create_interview_session create_work_item get_auth_token get_document_content get_template_package get_unanswered_variables get_work_item list_documents list_template_packages list_template_versions list_work_items list_work_items_by_date update_answers

Document creation used to be a multi-step nightmare.

Think about what you do today: You open Template A in the browser. You copy data from Google Sheets into Field 3, then switch tabs and open Template B. You manually fill in client names, dates, and amounts, cross-referencing them constantly to make sure everything matches up. Then you hit 'Save' and hope you didn't miss a field.

With this MCP server, your AI agent handles the whole mess. You just tell it, 'Draft the NDA for Acme Corp.' The agent finds the right template package (`list_template_packages`), gathers all necessary data (using `create_interview_session` if needed), and spits out a complete, ready-to-download document via `get_document_content`. No clicks. No copy-pasting.

HotDocs Advance MCP Server: Automate assembly with `complete_assembly`.

Before, generating a batch of documents meant exporting data into CSVs and running them through a separate reporting tool. You had to manually track which document corresponded to which input record, creating massive audit headaches just to prove completeness.

Now, the system manages the state. After you call `update_answers` with all 50 records' data, calling `complete_assembly` processes the entire batch and gives you a list of IDs via `list_documents`. It’s a single, reliable step that guarantees the document assembly process is finished.

Common Questions About HotDocs MCP

What credentials do I need to connect HotDocs Advance to this MCP server? +

You need four pieces of information: (1) your Tenancy Moniker (the subdomain in your HotDocs URL, e.g., 'mycompany' from mycompany.hotdocsadvance.com), (2) the API Client Display Name you created in Manage API Credentials, (3) the Service Principal Name you added to that client, and (4) the Service Principal Password (which is shown only once during creation). All of these are obtained from the HotDocs Advance Auth portal.

Can I assemble documents automatically without going through the interview UI? +

Yes! Use the create_work_item tool to initialize a work item, then use update_answers to inject your data as HotDocs answer XML, and finally call complete_assembly to trigger document generation. This fully automated bypasses the interactive interview UI entirely, perfect for batch processing or integrating with external data sources.

How do I find and download documents that have already been assembled? +

Use the list_documents tool with your workItemId to see all assembled documents and their IDs. Then use get_document_content with the workItemId and documentId to retrieve the actual file content. The response includes both the raw content and a direct download URL for easy access to your PDFs or Word documents.

What is a work item and why is it important? +

A work item is a unique container in HotDocs Advance that holds interview answers, template associations, and assembled documents for a specific case. Think of it as a 'file folder' for each document automation request. It's identified by a unique ID you assign (like 'contract-john-doe-2024') and persists all data so you can revisit, update, and reassemble documents at any time.

What should I do first when I use the `list_template_packages` tool? +

You receive a list of all document templates available in your tenancy. This step is essential because it provides the necessary package IDs you'll need to create any subsequent work items.

When should I run `get_unanswered_variables`? +

You run this after assembly attempts or interviews are complete. It checks which template variables never received answers, allowing you to validate data completeness before generating final documents.

What details does the `get_work_item` tool provide? +

It returns a full status snapshot of your work item. You can see if interview sessions were started, if answers were updated, or when the last action occurred for auditing purposes.

What format is required when I call `update_answers`? +

You must provide a valid XML answer set. The structure needs to match the template variables exactly; it’s designed for batch updates, not conversational input.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 14 tools

We've already built the connector for HotDocs. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 14 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.