DocMake

Seus documentos, gerados pelo seu assistente de IA.

O servidor oficial DocMake para o Model Context Protocol. Peça ao Claude uma fatura em linguagem simples; ele escolhe o modelo, preenche os campos (o payload data) e entrega o PDF finalizado.

Ele é distribuído no npm como @docmake/mcp e roda localmente via npx, então os únicos requisitos são Node.js 18 ou mais recente e uma chave de API DocMake. Funciona no plano gratuito e dá ao assistente seis ferramentas: listar modelos, inspecionar os campos de um modelo, gerar um documento (render_document), criar um modelo, importar um DOCX e verificar o uso. O código-fonte está no GitHub sob licença MIT, e as mesmas seis ferramentas também estão hospedadas em app.docmake.io/mcp/v1 se você preferir não instalar nada.

Uma conversa, não uma integração

MCP é o padrão aberto que permite que assistentes de IA usem ferramentas externas. Com o servidor DocMake instalado, seu assistente ganha seis ferramentas de documentos e as usa por conta própria: ele encontra o modelo certo, pede os valores que faltam e salva o arquivo renderizado na sua pasta Downloads.

As renderizações são estritas por padrão. Se um campo (um variable na API) não tiver valor, o assistente recebe a lista exata dos campos ausentes em vez de um documento pela metade, então ele pergunta a você em vez de inventar números.

Os modelos ficam no DocMake: crie-os uma vez no editor visual ou comece pela galeria e renderize-os de qualquer lugar.

Claude

Gere a fatura para a Acme Corp: 10 horas de consultoria a 100 EUR, vencimento em 14 dias.

ferramenta list_templates → Invoice (tmpl_ZjqIJk...)
ferramenta get_template → client_name, items[], due_date...
ferramenta render_document → invoice-acme.pdf

Pronto. Sua fatura para a Acme Corp (1.000,00 EUR, vencimento em 23 de agosto) foi salva em ~/Downloads/DocMake/invoice-acme.pdf.

Configuração

1. 01 Crie uma conta gratuita no DocMake e adicione um modelo: comece pela galeria, importe um DOCX ou crie o seu.
2. 02 Crie uma chave de API em Configurações → Chaves de API.
3. 03 Adicione o servidor à sua ferramenta de IA com a configuração à direita. Node.js 18+ é o único requisito.

Os arquivos renderizados são salvos em ~/Downloads/DocMake por padrão; defina DOCMAKE_OUTPUT_DIR para alterar.

{
  "mcpServers": {
    "docmake": {
      "command": "npx",
      "args": ["-y", "@docmake/mcp@latest"],
      "env": {
        "DOCMAKE_API_KEY": "dm_your_api_key"
      }
    }
  }
}

Configurações > Desenvolvedor > Editar Config e reinicie o Claude Desktop.

Remoto, nada para instalar

As mesmas seis ferramentas, hospedadas

O DocMake também executa o servidor para você em https://app.docmake.io/mcp/v1, falado via HTTP streamable. Um cliente que suporta MCP remoto não precisa de pacote nem de Node.js: apenas a URL e um cabeçalho, Authorization: Bearer dm_..., carregando a mesma chave de API que a API REST usa.

Duas coisas diferem do pacote local, porque o servidor roda do nosso lado em vez de na sua máquina. render_document retorna um link de download de curta duração em vez de gravar o arquivo em disco, e import_docx recebe o documento como base64 em vez de um caminho. Renderização estrita, escopo do workspace e limites de taxa do plano se comportam como na REST, onde uma mensagem MCP conta como uma requisição.

Claude.ai e ChatGPT adicionam servidores remotos como conectores personalizados, e esses são documentados em torno de um fluxo OAuth em vez de uma chave estática, então esta configuração ainda não os alcança. Para o Claude Desktop, use a configuração npx acima.

claude mcp add --transport http docmake \
  https://app.docmake.io/mcp/v1 \
  --header "Authorization: Bearer dm_your_api_key"

Adiciona o servidor ao projeto atual. Passe --scope user para disponibilizá-lo em qualquer lugar.

Lado a lado

Mesmas seis ferramentas, mesmo workspace, mesma chave dm_. Escolha onde você quer que o trabalho aconteça, não o que você recebe.

	Local, @docmake/mcp	Hospedado, /mcp/v1
Transporte	stdio, executado pelo seu cliente via npx	HTTP streamable, um POST por mensagem
Requisitos	Node.js 18 ou mais recente	Nada instalado
Autenticação	DOCMAKE_API_KEY no ambiente	Cabeçalho Authorization: Bearer dm_...
Ferramentas	As mesmas seis	As mesmas seis
Um arquivo renderizado	Gravado em DOCMAKE_OUTPUT_DIR, ~/Downloads/DocMake por padrão, nunca sobrescrevendo	Um link de download assinado que não precisa de chave e expira
import_docx	Um caminho na sua máquina	O arquivo codificado em base64, até 10 MB
Recursos e prompts	Anunciados junto com as ferramentas	Somente ferramentas, ambas as listas vazias
Versão	0.1.1 no npm	0.1.0, informada no handshake
Limite de taxa	O orçamento do workspace, uma chamada é uma requisição	O mesmo orçamento, uma mensagem é uma requisição

Seis ferramentas, o ciclo completo de documentos

As mesmas seis em ambos os servidores, com os mesmos nomes, os mesmos argumentos e as mesmas respostas. Tudo o que um assistente precisa para ir de uma solicitação a um arquivo renderizado, incluindo criar e importar modelos sem sair da conversa.

list_templates

Listar modelos

Os modelos no workspace conectado, edição mais recente primeiro, com busca e paginação. Comece aqui quando precisar de um id de modelo.

search

string

Filtrar por nome, correspondência de substring

page

integer

A partir de 1

per_page

integer

Máximo 100, padrão 20

Retorna data: id, name, created_at, updated_at, variables_count, render_count. meta: current_page, last_page, per_page, total.

Somente leitura.

get_template

Obter campos do modelo

Um modelo mais sua árvore de campos: cada campo que ele espera, como chaves pontilhadas no formato do payload de dados, com campos de lista carregando seus subcampos por item. Chame antes de renderizar.

template_id

string, obrigatório

De list_templates

include_schema

boolean

Também retorna o schema bruto do documento. Padrão false, pode ser grande

Retorna id, name, created_at, updated_at, fields (recursivo: key, name, label, type, required, default, example), unused.

Somente leitura. Um cálculo é uma saída, então não está em nenhuma das listas.

render_document

Renderizar um documento

Renderiza um modelo em PDF ou DOCX. Responde com um link de download de curta duração, não os bytes do arquivo, e recusa em vez de preencher um documento com lacunas.

template_id

string, obrigatório

data

object, obrigatório

As chaves correspondem aos campos do modelo

format

pdf ou docx

Padrão pdf

filename

string

Sem extensão

locale

string

BCP 47, por exemplo ro-RO. Padrão é a configuração do workspace

page_size

a4 ou letter

Padrão é a configuração do workspace

strict

boolean

Padrão true

Retorna document_id, filename, format, size_bytes, render_time_ms, warnings, download_url, download_expires_at.

Grava. Não é idempotente: cada chamada produz um documento.

create_template

Criar modelo

Cria um modelo a partir de um schema de documento: uma árvore de rich text com nós de campos tipados, regras e seções repetidas. A forma mais rápida de aprender o formato é get_template com include_schema true.

name

string, obrigatório

Máximo 255

schema

object, obrigatório

A raiz deve ser do tipo "doc" com um array content

Retorna id, name, variables, edit_url.

Grava. Conta para o limite de modelos.

import_docx

Importar um DOCX como modelo

Transforma um documento do Word em um modelo editável: títulos, parágrafos, tabelas e estilos são convertidos, e então você adiciona campos no editor ou inspeciona o resultado com get_template.

file_base64

string, obrigatório

Os bytes do .docx, em base64. Máximo 10 MB decodificados

name

string

Padrão "Imported document"

Retorna id, name, import_warnings, edit_url.

Grava. O pacote local aceita um caminho de arquivo em vez disso.

get_usage

Obter uso e limites

Plano, documentos usados contra o limite mensal, contagem de modelos, créditos de IA e o limite de taxa por minuto. Verifique quando as renderizações começarem a falhar por cota.

Retorna plan, billing_period, renders, templates, credits, api_calls, rate_limit.

Somente leitura. Não aceita argumentos.

Prefere HTTP puro? As mesmas capacidades estão disponíveis na API REST, onde os erros, o cabeçalho X-DocMake-Warnings e o modo estrito estão documentados por completo.

Uma execução, de ponta a ponta

Isto é o que um assistente realmente faz, mostrado como JSON-RPC bruto contra o servidor hospedado para que você possa acompanhar apenas com curl. Cada chamada e cada resposta abaixo foi executada contra https://app.docmake.io/mcp/v1 com uma chave real e colada de volta sem edição; a chave e a assinatura foram ocultadas.

0. Abrir uma sessão

HTTP streamable: um POST por mensagem, com a chave no cabeçalho Authorization. O servidor responde ao handshake com um id de sessão para enviar de volta em todas as chamadas seguintes.

curl -sS -X POST https://app.docmake.io/mcp/v1 \
  -H "Authorization: Bearer dm_xxx" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize",
       "params":{"protocolVersion":"2025-06-18","capabilities":{},
                 "clientInfo":{"name":"curl","version":"1.0"}}}'

mcp-session-id: b988daa4-cb37-470d-92f5-fe6badbe3dc1

{"jsonrpc":"2.0","id":1,"result":{
  "protocolVersion":"2025-06-18",
  "capabilities":{"tools":{"listChanged":false},
                  "resources":{"listChanged":false},
                  "prompts":{"listChanged":false}},
  "serverInfo":{"name":"docmake","version":"0.1.0"}, ... }}

1. Encontrar o modelo

{"jsonrpc":"2.0","id":3,"method":"tools/call",
 "params":{"name":"list_templates","arguments":{"search":"formula"}}}

{
  "data": [
    {
      "id": "tmpl_xYucq408uKkJ",
      "name": "Docs formula example",
      "created_at": "2026-09-03T05:48:46+00:00",
      "updated_at": "2026-09-03T05:49:21+00:00",
      "variables_count": 5,
      "render_count": 2
    }
  ],
  "meta": { "current_page": 1, "last_page": 1, "per_page": 20, "total": 1 }
}

2. Perguntar o que ele precisa

As chaves são pontilhadas e no formato do payload, então um assistente pode montar o objeto de dados sem adivinhar. Um campo de lista carrega seus campos por item. Cálculos são saídas e não aparecem em nenhum lugar desta árvore.

{"jsonrpc":"2.0","id":4,"method":"tools/call",
 "params":{"name":"get_template","arguments":{"template_id":"tmpl_xYucq408uKkJ"}}}

{
  "id": "tmpl_xYucq408uKkJ",
  "name": "Docs formula example",
  "fields": [
    {
      "key": "client", "name": "client", "label": "Client",
      "type": "object", "required": false, "default": null, "example": null,
      "fields": [
        { "key": "client.name", "name": "name", "label": "Client name",
          "type": "string", "required": false, "default": null, "example": null }
      ]
    },
    {
      "key": "items", "name": "items", "label": "Items",
      "type": "array", "required": false, "default": null, "example": null,
      "fields": [
        { "key": "items.product", ... },
        { "key": "items.qty", ... },
        { "key": "items.unit_price", ... }
      ]
    }
  ],
  "unused": []
}

3. Renderizar e ler os avisos

A resposta carrega um array warnings no mesmo formato do cabeçalho X-DocMake-Warnings da API REST: vazio aqui, porque nada estava faltando. O link não precisa de chave de API e expira, então pode ser entregue diretamente à pessoa que pediu.

{"jsonrpc":"2.0","id":5,"method":"tools/call",
 "params":{"name":"render_document","arguments":{
   "template_id":"tmpl_xYucq408uKkJ","format":"pdf","filename":"quote-northwind",
   "data":{"client":{"name":"Northwind Trading SRL"},"discount_percent":10,
     "items":[{"product":"Consulting","qty":1,"unit_price":2500},
              {"product":"Internal audit","qty":2,"unit_price":800},
              {"product":"Training","qty":3,"unit_price":350}]}}}}

{
  "document_id": "doc_M6fQVkMHLp04",
  "filename": "quote-northwind.pdf",
  "format": "pdf",
  "size_bytes": 21384,
  "render_time_ms": 1386,
  "warnings": [],
  "download_url": "https://app.docmake.io/mcp/documents/doc_M6fQVkMHLp04?expires=...&signature=...",
  "download_expires_at": "2026-09-03T06:50:22+00:00"
}

4. O que acontece quando algo está faltando

A mesma chamada sem um nome de cliente. As renderizações são estritas por padrão aqui, então nada é produzido e a ferramenta responde com o problema e a saída. O assistente pede o valor a você em vez de inventar um.

{
  "content": [
    {
      "type": "text",
      "text": "Nothing was rendered: client.name has no value. Ask the user for the right values and call render_document again, or pass strict:false to render anyway with missing values left blank."
    }
  ],
  "isError": true
}

Código-fonte e listagens

O servidor local é open source, publicado no npm e listado no registro oficial do Model Context Protocol, então você pode ler o código antes de executá-lo.

[

Código-fonte

docmake-io/mcp

Open source sob licença MIT, marcado como v0.1.1.

](https://github.com/docmake-io/mcp)[

Pacote

@docmake/mcp

Versão 0.1.1 no npm, executado com npx, sem instalação global.

](https://www.npmjs.com/package/@docmake/mcp)[

Registro

io.docmake/mcp

Listado no registro oficial do Model Context Protocol.

](https://registry.modelcontextprotocol.io/v0/servers?search=io.docmake/mcp)

Perguntas

O que é o servidor MCP do DocMake?

Um pacote npm open source (@docmake/mcp) que conecta assistentes de IA à sua conta DocMake por meio do Model Context Protocol. Uma vez instalado, assistentes como o Claude podem listar seus modelos, verificar quais campos eles precisam e renderizar documentos PDF ou DOCX finalizados a partir de uma conversa simples.

Quais ferramentas de IA funcionam com ele?

Qualquer cliente MCP: Claude Desktop, Claude Code, Cursor, Zed, Windsurf e outros. A configuração é a mesma em todos os lugares: execute @docmake/mcp via npx com sua chave de API no ambiente. Claude Code, Cursor e VS Code também podem apontar para o servidor hospedado, com a chave de API enviada como cabeçalho Authorization.

É open source?

Sim. O servidor está publicado em github.com/docmake-io/mcp sob licença MIT, o pacote é @docmake/mcp no npm e está listado no registro oficial do Model Context Protocol como io.docmake/mcp.

Posso usar sem instalar nada?

Sim. O DocMake hospeda as mesmas seis ferramentas em https://app.docmake.io/mcp/v1 via HTTP streamable. Aponte um cliente que suporta MCP remoto para essa URL e envie sua chave de API como cabeçalho Authorization: Bearer dm_... Três coisas diferem do pacote local: documentos renderizados voltam como links de download de curta duração em vez de arquivos locais, import_docx aceita base64 em vez de um caminho de arquivo, e o servidor hospedado expõe apenas ferramentas, enquanto o pacote também anuncia recursos e um prompt.

Precisa de um plano pago?

Não. O plano gratuito inclui acesso à API, então o servidor MCP funciona desde o momento em que você se cadastra. Planos pagos aumentam o volume mensal de documentos e removem a marca do rodapé.

Meus dados estão seguros?

O servidor local roda na sua máquina e fala apenas com a API do DocMake via HTTPS com sua chave de API. Documentos renderizados são salvos em uma pasta que você controla. O servidor hospedado roda dentro do DocMake e trata seus dados da mesma forma que a API REST, sob a mesma política de privacidade. Nada é enviado a terceiros em nenhum dos casos.