HotDocs MCP. Automate complex document assembly from natural language prompts.
Works with every AI agent you already use
…and any MCP-compatible client
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.
The agent lists all template packages and their versions in your account using list_template_packages.
You create a new, unique work item record using create_work_item, which serves as the reference point for all subsequent data and documents.
The agent starts an interview session via create_interview_session to guide your client through collecting specific answers needed for the template variables.
You inject bulk answers into a work item using XML format with update_answers, skipping interactive input when you already have the data.
The agent triggers the full assembly process by calling complete_assembly to generate all necessary document files.
You check for gaps using get_unanswered_variables to identify which required fields were left blank before final assembly.
Ask AI about this MCP
Supported MCP Clients
Waiting for input…
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.
019d75b3complete assembly
Generates the final documents (PDFs, Word docs) using all collected data for a specific work item version.
019d75b3create interview session
Starts an interactive session that collects answers needed for document variables before assembly can happen.
019d75b3create work item
Establishes a unique record in the system, linking it to a specific template package and ID.
019d75b3get auth token
Retrieves an up-to-date API access token. Use this if other tools fail with authentication errors.
019d75b3get document content
Downloads the actual content of a generated document using its unique ID after assembly is complete.
019d75b3get template package
Retrieves structural details for a specific template package ID, helping you understand its requirements before use.
019d75b3get unanswered variables
Checks a document to list any variables that were required by the template but never received an answer.
019d75b3get work item
Fetches all data associated with one specific work item ID at any point in the workflow.
019d75b3list documents
Lists all generated documents for a given work item, providing their file IDs and metadata.
019d75b3list template packages
Retrieves a list of every template package available in your account to determine what can be assembled.
019d75b3list template versions
Lists the version history for any specific template package ID.
019d75b3list work items
Finds work items using optional filters like user IDs or date ranges, useful for auditing records.
019d75b3list work items by date
Lists all work items that fall within a specific start and end date range (ISO 8601 format).
019d75b3update 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
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 First, the agent calls
create_work_item, giving it a unique ID and selecting the template package. - 2 Next, the agent can run an interview via
create_interview_sessionor inject data directly usingupdate_answers. Once all variables are populated, the agent triggerscomplete_assembly. - 3 The final step is calling
list_documentsto find the generated file ID, and then runningget_document_contentto 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.
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.
Handling employee onboarding and offboarding. The agent automatically creates employment contracts or policy acknowledgments using pre-approved templates at scale.
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_variablesto 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_answerswith 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 calllist_documentsand thenget_document_contentto download the ready-to-use PDF or Word file. - Track everything across teams. You can find specific records using
list_work_items_by_dateor narrow down searches by user ID withlist_work_items, making compliance auditing simple.
Real-World Use Cases
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.
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.
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.
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
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
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Bear
Manage your Bear notes via AI — search, create, and organize your markdown knowledge base autonomously.
Join
Manage recruiting, jobs, and candidates via JOIN API.
SimplyBook.me
Enable your AI agent to manage appointments, browse staff calendars, and handle client records via the SimplyBook.me scheduling platform.
You might also like
Height (Project Management)
Manage projects and tasks via Height — track activities, list tasks, and manage workspace lists.
NeetoCal
Let clients book appointments through your personalized scheduling page with calendar sync and automatic reminders.
Robly
Automate email marketing via Robly — manage contacts, subscriber lists, and campaign stats with AI.