Skip to main content
Glama

An open-source Model Context Protocol server that gives Claude Desktop (or any MCP client) a persistent master résumé, a real ATS keyword score, and clean PDF / DOCX export.

PyPI Website CI License: MIT Python 3.11+ MCP PRs Welcome Built for Claude

🌐 View the live site →

Quick start · Tools · How it works · Contributing · Releases


You: "Here's a job link — tailor my CV and export a PDF."

Claude reads the posting and your master CV, rewrites it to match, checks the ATS keyword score, and hands you a clean file ready to send.

Table of Contents

Related MCP server: ats-resume-writer

Why this exists

Claude can already rewrite a CV in a normal chat. This MCP is worth installing for the three things a plain chat can't do:

Feature

What it gives you

Persistent master CV

Stored locally as JSON. Set it up once, reuse it for every job.

Real ATS gap score

Deterministic keyword math — not vibes. Tells you exactly which keywords you're missing.

Clean file export

ATS-safe PDF / DOCX: single column, standard fonts, real selectable text.

IMPORTANT

The MCP does not rewrite your CV — Claude does that. The server supplies the persistence, the job fetch, the ATS math, and the export. Claude ties it together.

How it works

 load_master_resume ─┐                                                  ┌─►  export_resume
                     ├─►  Claude rewrites the CV  ─►  ats_gap_check  ─►──┤
 fetch_job_posting ─►│                                     ▲            └─►  export_cover_letter
 extract_keywords ───┘─────────────────────────────────────┘
  1. Load your master CV — load_master_resume

  2. Analyze the job — fetch_job_posting → extract_keywords

  3. Rewrite — Claude rewrites the CV to honestly surface the missing keywords

  4. Check the rewrite — ats_gap_check (did the score go up?)

  5. Export — export_resume → a clean PDF or DOCX

  6. Cover letter (optional) — export_cover_letter → a matching PDF or DOCX

Tools

Tool

Purpose

save_master_resume

Store/update the base CV (structured JSON: contact, summary, experience, projects, skills, education).

load_master_resume

Return the stored master CV so Claude can work from it.

fetch_job_posting

Fetch a job URL → clean text. Falls back to pasted text if the site is blocked or login-walled.

extract_keywords

Deterministically pull the ranked skills/tools an ATS scans for.

ats_gap_check

Compare a CV against the job keywords → match score (%) + the exact missing terms.

export_resume

Render finished CV content (markdown or JSON) → a clean PDF or DOCX. Returns the file path.

export_cover_letter

Render a finished cover letter → a matching PDF or DOCX. Optionally adds a letterhead (name + contact) from the master CV. Returns the file path.

Installation

pip install resume-tailor-mcp     # or: uvx resume-tailor-mcp

That installs a resume-tailor-mcp command that runs the MCP server.

Option B — from source

git clone git@github.com:NmaaAlhawary/MCP-Resume-Tailor.git
cd MCP-Resume-Tailor

python3 -m venv .venv
source .venv/bin/activate          # fish: source .venv/bin/activate.fish
pip install -r requirements.txt

Smoke-test that all seven tools register:

python -c "import asyncio, server; print([t.name for t in asyncio.run(server.mcp.list_tools())])"
NOTE

PDF export usesreportlab (pure Python — no system libraries needed on macOS/Windows/Linux). DOCX export uses python-docx.

Connect to Claude Desktop

Add this to your claude_desktop_config.json (~/Library/Application Support/Claude/claude_desktop_config.json on macOS).

If you installed from PyPI (simplest — uvx fetches and runs it):

{
  "mcpServers": {
    "resume-tailor": {
      "command": "uvx",
      "args": ["resume-tailor-mcp"],
      "env": { "RESUME_STORE_PATH": "~/.resume-mcp/master.json" }
    }
  }
}

If you installed from source, point at your venv's Python and server.py:

{
  "mcpServers": {
    "resume-tailor": {
      "command": "/absolute/path/to/MCP-Resume-Tailor/.venv/bin/python",
      "args": ["/absolute/path/to/MCP-Resume-Tailor/server.py"],
      "env": { "RESUME_STORE_PATH": "~/.resume-mcp/master.json" }
    }
  }
}

Restart Claude Desktop — the seven tools appear under the tools menu.

Usage

First-time setup — store your master CV (once)

Copy master.template.json, fill in your details, then ask Claude:

"Save this as my master resume: (paste the JSON)"

Claude calls save_master_resume and it persists at RESUME_STORE_PATH.

Everyday flow — tailor to a job

You: Here's a job link — tailor my CV for it and export a PDF: https://example.com/careers/senior-frontend

Behind the scenes Claude runs:

1. load_master_resume()                          → your stored CV
2. fetch_job_posting(url="…/senior-frontend")    → clean job text
3. extract_keywords(job_text)                    → ["REST APIs", "GraphQL", "TypeScript",
                                                     "Docker", "AWS", "Next.js", "CI/CD", …]
4. ats_gap_check(resume_text, keywords)          → { match_score: 20.0,
                                                     missing: ["GraphQL","Docker","AWS",…] }
5. ── Claude rewrites the CV to surface real, matching skills ──
6. ats_gap_check(new_resume_text, keywords)      → { match_score: 85.0 }
7. export_resume(content=<rewritten>, format="pdf")
                                                 → { path: "~/.resume-mcp/exports/…​.pdf" }
8. export_cover_letter(content=<letter>, format="pdf")
                                                 → { path: "~/.resume-mcp/exports/…​_cover_letter.pdf" }

Claude: Tailored your CV — keyword match went from 20% → 85%. I added your Docker/AWS and testing experience to match their stack, and drafted a matching cover letter. Exported here: ~/.resume-mcp/exports/Jane_Developer_….pdf ~/.resume-mcp/exports/Jane_Developer_…_cover_letter.pdf

Configuration

Env var

Default

Purpose

RESUME_STORE_PATH

~/.resume-mcp/master.json

Where the master CV JSON lives. Exports go to exports/ next to it.

Everything runs locally. No secrets, no external accounts.

Safety & robustness

  • SSRF-guarded fetching — fetch_job_posting only follows http/https URLs to public hosts. Requests to localhost, private/LAN ranges, or cloud metadata (169.254.169.254) are refused, and redirects are re-checked on every hop. Downloads are capped at ~3 MB.

  • Synonym-aware ATS scoring — the gap check treats common equivalents as a match (e.g. K8s↔Kubernetes, JS↔JavaScript, Postgres↔PostgreSQL), so scores reflect real coverage.

  • Unicode-safe PDFs — a bundled Unicode font renders accented names (José, résumé) correctly instead of empty boxes.

  • Master-CV backup — saving over an existing master CV first writes a .bak copy.

ATS-safe export

  • Single column — no text boxes or multi-column tricks that break ATS parsers

  • Standard fonts (Calibri for DOCX, a Unicode sans for PDF)

  • Real, selectable text — never image-rendered

  • Plain headings and bullet lists that map cleanly to resume sections

Contributing

Contributions of any size are welcome. The quickest way in: fork the repo, make your change, and open a pull request.

# 1. Fork on GitHub, then clone your fork
git clone git@github.com:YOUR-USERNAME/MCP-Resume-Tailor.git
cd MCP-Resume-Tailor

# 2. Set up and branch
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
git checkout -b my-improvement

# 3. Change, commit, push
git commit -am "Describe your change"
git push origin my-improvement

# 4. Open a Pull Request on GitHub

Great first contributions: add skills to KNOWN_TERMS / KNOWN_PHRASES in server.py, filter a filler word in STOPLIST, or improve the export layout. See CONTRIBUTING.md for the full step-by-step guide.

License

Released under the MIT License. By contributing, you agree your contributions are licensed under the same terms.

Built by Nmaa Hawary · If this helped, consider giving it a star.

Available Tools

6 tools
ats_gap_checkA

Compare a CV against job keywords → match score (%) + missing terms.

This is the tool's killer feature: it tells the user concretely what to add. Pass the resume as plain text and the ranked keyword list from extract_keywords. Returns which keywords are present, which are missing, and a match percentage — so Claude knows exactly what to surface in the rewrite.

Returns {match_score, matched, missing, total_keywords}.

Inputs: keywords (required), resume_text (required). Returns: object

export_resumeA

Render finished CV content to a clean, ATS-safe PDF or DOCX file.

Pass content as either markdown text (use #/##/### headings and - bullets) OR structured CV JSON (same shape as the master resume). Choose format = "pdf" or "docx". The layout is deliberately single-column with standard fonts and real text (never image-rendered) so ATS parsers read it.

Returns {path, format, blocks} with the saved file path.

Inputs: content (required), format, filename. Returns: object

extract_keywordsA

Pull the skills/tools/keywords an ATS would scan for from a job posting.

Deterministic (no ML): tokenizes the text, filters filler words, recognizes known skills and multi-word phrases (e.g. "REST APIs"), and ranks by frequency — boosting terms that appear in skills/requirements sections.

Returns {keywords: [ranked strings], detail: [{keyword, score, known_skill}]}. Use the ranked keyword list as input to ats_gap_check.

Inputs: job_text (required), top_n. Returns: object

fetch_job_postingA

Get a job posting as clean readable text.

Pass a url to fetch and strip a posting to plain text, OR pass pasted_text directly if you already have the description. URL fetching is best-effort: if the site is blocked or login-walled, this returns a clear message asking the user to paste the text instead — it never fails silently.

Returns {source, text, char_count}.

Inputs: url, pasted_text. Returns: object

load_master_resumeA

Return the stored master CV so Claude can tailor it to a job.

This is the starting point of every tailoring session. If no resume is stored yet, raises a clear error telling the user to save one first.

Inputs: no named parameters. Returns: object

save_master_resumeA

Store or update the user's base CV so it persists between sessions.

Provide the CV as structured JSON. Recommended keys: contact - {name, email, phone, location, links} summary - short professional summary (string) experience - list of {title, company, location, start, end, bullets[]} projects - list of {name, description, tech[], link} skills - list of strings (or {category, items[]}) education - list of {degree, school, location, start, end, details}

This is step 1 of the flow: set it up once, reuse it for every job. Returns a confirmation with the stored path.

Inputs: resume (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 6 tools

    Disambiguation5/5

    Each tool has a distinct, non-overlapping purpose: fetching job posts, extracting keywords, analyzing gaps, managing the master resume, and exporting. An agent can clearly distinguish them.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern in snake_case (e.g., fetch_job_posting, extract_keywords), making them predictable and easy to understand.

    Tool Count5/5

    With 6 tools, the scope is well-balanced: each tool serves a necessary step in the resume tailoring workflow without redundancy or excessive complexity.

    Completeness4/5

    The set covers the core pipeline from job posting to export, but lacks a dedicated tool to save tailored resume versions separately from the master. This minor gap is manageable for agents.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers