Why We Built an MCP Server for Document Generation

---

The Gap in AI Agent Capabilities

Picture this: you're using Claude to analyze your quarterly sales data. It queries your database, crunches the numbers, identifies trends, and writes a summary. Then you say:

"Great. Now turn that into a PDF report I can send to the board."

And suddenly, the most capable AI in the world is stuck. It can give you Markdown. It can generate HTML. But a real, formatted PDF with your company logo, charts, page numbers, and a professional layout? That requires infrastructure the AI agent simply doesn't have access to.

This is the gap we built Rynko's MCP server to fill.

What Is MCP?

Model Context Protocol (MCP) is an open standard that allows AI assistants to connect to external tools and services. Think of it as a USB port for AI—a standardized way for models like Claude to interact with the outside world.

When you connect an MCP server to Claude Desktop or Cursor, the AI gains new abilities. It can read files, query APIs, execute code—anything the server provides.

Our MCP server enables AI agents to design templates, generate documents, and manage the entire document lifecycle—all through natural conversation.

What Our MCP Server Can Do

Here are the tools provided by the Rynko Document Generation MCP:

1. list_workspaces — List all workspaces you have access to, including workspace names, team names, and your role.

2. get_workspace — Get details about a specific workspace including template count and team information.

3. list_templates — List templates in a workspace, filterable by format (PDF or Excel).

4. get_template — Get full details of a template including schema, variables, and settings.

5. create_draft_template — Create a new draft template with a defined schema and variables.

6. update_draft_template — Update an existing template's draft version (name, description, schema, or variables).

7. validate_schema — Validate a template schema without creating a template; returns any validation errors.

8. get_schema_reference — Fetch the complete Rynko template schema reference documentation (all component types, examples, styling, validation rules, etc.).

9. parse_data_file — Parse an Excel or CSV file and return structured JSON data for document generation.

10. map_variables — Auto-map data columns to template variables based on name similarity, with confidence scores.

11. preview_template — Generate a free preview of a document with a download URL (valid 5 minutes). Doesn't consume credits.

12. generate_document — Generate a production document (consumes credits). Returns a job ID for status tracking.

13. get_job_status — Check the status of a document generation job and get the download URL when complete.

14. list_assets — List image assets in your asset library (returns assets://{id} references for use in templates).

15. upload_asset — Upload an image (base64 or public URL) to the asset library for use in templates.

16. get_sdk_examples — Get SDK code examples and documentation for programmatic integration (Node.js, Python, Java, REST).

These cover the full lifecycle — from workspace/template management, schema authoring and validation, data parsing and variable mapping, to preview, generation, asset management, and developer integration.

Template Creation and Management

Your AI agent can create document templates from a natural language description:

The agent will create a well-structured template with all the necessary components, variables, and layout using our template schema. Templates created through MCP begin as drafts, ensuring nothing goes to production without your review.

Document Generation

Once you have a template, generating documents is a single conversation turn:

"Generate a PDF invoice for Acme Corp using the invoice template.
Invoice #INV-2026-042, 3x Consulting Hours at $150/hr,
1x Software License at $500. 8% tax."

The agent fills in the variables, calls the generation API, and provides a download link. You can also create Excel files from the same template—just ask.

Previews are free. The agent can generate preview documents without using up your monthly quota, allowing you to refine templates without worrying about costs.

Data Import

Have data in a spreadsheet? The agent can parse it and map it to your template:

"Parse this CSV file and map the columns to the invoice template variables"

The parse_data_file and map_variables tools manage Excel and CSV files by automatically matching column headers to the template variable names.

Asset Management

Templates often need images, such as logos, signatures, and icons. The agent can upload and manage these assets:

"Upload our company logo for use in templates"

Assets are stored in your team's library and can be used in all templates.

Setup: Just 2 Minutes, No Coding Needed

Step 1: Acquire a Personal Access Token

1. Log into app.rynko.dev

2. Go to Settings > Personal Access Tokens

3. Create a new token (expires in 30 days for security)

Step 2: Integrate with Your AI Tool

Claude Desktop — download the .mcpb extension from our GitHub releases and drag it into Settings > Extensions. Enter your token when prompted. That's it.

Or, if you prefer manual config, edit claude_desktop_config.json:

{
  "mcpServers": {
    "rynko": {
      "command": "npx",
      "args": ["-y", "@rynko/mcp-server"],
      "env": {
        "RYNKO_USER_TOKEN": "pat_your_token_here"
      }
    }
  }
}

Cursor — Open Settings (Cmd+, / Ctrl+,) → Features → MCP → Add New MCP Server. Enter the name rynko, select the type command, input the command npx -y @rynko/mcp-server, and add the environment variable RYNKO_USER_TOKEN with your token. Save and restart.

Upon restarting Cursor, the document generation tools will be available immediately.

We also support Windsurf, VS Code, and Zed — see our MCP integration guide for setup instructions.

Why Choose MCP Over a Standard API?

You might wonder — why build an MCP server when we already have a REST API?

The answer is context and intent.

When a developer integrates our API, they write code that knows exactly what template to use, what variables to pass, and what format to generate. The logic is hardcoded.

When an AI agent uses our MCP server, it can reason about the problem. It can:

• Browse available templates and pick the right one based on name, description, and format

• Inspect a template's variables — see what fields exist, what types they expect, what defaults are set — and map incoming data to them (we even have a map_variables tool that does fuzzy column-to-variable matching)

• Generate a free preview first, check if the output looks right, and regenerate with tweaked data if needed

• Create an entirely new draft template from scratch if none of the existing ones fit

The difference is that the API caller needs to know exactly what to do upfront. The MCP caller can explore, inspect, and iterate — more like a junior developer with access to your template library than a script executing a fixed pipeline.

Real-World Workflows

Here are workflows where MCP actually makes sense — cases where a human is in the loop and the AI is doing the legwork interactively:

Ad-Hoc Invoice Generation

You're in a chat with Claude and a client just confirmed a project scope over email. You say: "Generate an invoice for Acme Corp — 3 months of consulting at $15k/month, net-30 terms." The agent lists your templates, picks your invoice template, inspects its variables, fills them in, generates a preview, and gives you a download link. You review it, ask for a tweak ("add a 10% early payment discount line"), and the agent regenerates. Two minutes, no context switching to a dashboard.

On-Demand Reporting

You ask Claude: "Generate this month's sales report." The agent queries your database (via a separate DB tool or MCP server you've configured), structures the data to match your report template's variables, and generates a PDF. This works well when the template already exists and the variables are straightforward — but you need the data source wired up separately. The MCP server handles the document generation part, not the data fetching.

Template Prototyping

You're building a new onboarding packet and don't want to spend 30 minutes in the visual designer for the first draft. You describe what you need: "Create a welcome letter template with company name, employee name, start date, and a list of first-week tasks." The agent uses create_draft_template to build a structured template, generates a preview with sample data, and you iterate from there. Once you're happy with the structure, you open it in the visual designer to polish the layout and publish.

Secure by Design

We prioritized security when building the MCP server:

• Personal Access Tokens expire after 30 days and are stored as SHA-256 hashes

• Draft-only mode — templates created via MCP are always drafts until manually published

• Workspace isolation — the MCP server enforces workspace selection at session start. The AI must list your workspaces, let you pick one, and lock to it before any template or document operations work. Switching workspaces requires explicit re-selection.

• Audit trail — every MCP operation is logged in your team's activity feed

• Token revocation — instantly revoke any token from the dashboard

Getting Started

1. Sign up for free — You'll get 5,000 credits with every new account!

2. Install the MCP server — It only takes 2 minutes to set up for Claude, Cursor, or any MCP client.

3. Ask your agent: "List my Rynko templates" — If it works, you're all set and connected!

We created this because we believe the future of document generation should be as easy as having a conversation. Instead of learning another API, you just tell your AI what you need.

Try It Free | MCP Setup Guide | Documentation

---

Questions? Join our Discord or check the npm package.

_{Disclosure: I ideate and draft content, then refine it with the aid of artificial intelligence tools like Claude and revise it to reflect my intended message.}