Skip to main content
Glama
MCP Resume & Job Analyzer

MCP Resume & Job Analyzer

by mohsiniqubal

MCP Resume & Job Analyzer

A portfolio-ready Model Context Protocol (MCP) project that exposes resume/job-analysis capabilities as tools an AI host can call.

What this project demonstrates

  • MCP server development with the current MCP Python SDK v2

  • Typed MCP tools and structured outputs

  • Resume text/PDF extraction

  • Deterministic skill matching and gap analysis

  • Job-fit scoring

  • Learning-plan generation

  • SQLite persistence

  • Unit testing

  • Docker-ready architecture

Related MCP server: resume-kit MCP Server

Architecture

User / AI Host
      |
      | MCP
      v
+-----------------------------+
| MCP Resume Job Analyzer     |
|                             |
| analyze_resume              |
| match_job                   |
| calculate_match_score       |
| get_learning_plan           |
| save_analysis               |
+-------------+---------------+
              |
       +------+------+
       |             |
   Analyzer      SQLite DB

Project structure

mcp_resume_job_analyzer/
├── src/
│   ├── __init__.py
│   ├── analyzer.py
│   └── server.py
├── data/
│   ├── sample_resume.txt
│   └── sample_job.txt
├── tests/
│   └── test_analyzer.py
├── requirements.txt
├── Dockerfile
├── .dockerignore
├── .gitignore
└── README.md

Setup

Python 3.10+ is required.

Windows

python -m venv .venv
.venv\Scripts\activate
pip install -r requirements.txt

Linux / macOS

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

Run the MCP server

python -m src.server

The server uses stdio transport, which is suitable for local MCP hosts.

Test with MCP Inspector

With the MCP CLI installed:

uv run mcp dev src/server.py

Then inspect the exposed tools.

Available MCP tools

analyze_resume

Extracts known skills, education, experience, projects and certifications from supplied resume text.

match_job

Compares a resume against a job description and returns matched skills, missing skills and evidence.

calculate_match_score

Calculates a transparent skill-based match score.

get_learning_plan

Creates a prioritized learning plan from missing skills.

save_analysis

Persists an analysis result into SQLite.

Example tool flow

1. analyze_resume(resume_text)
2. match_job(resume_text, job_description)
3. calculate_match_score(...)
4. get_learning_plan(missing_skills)
5. save_analysis(...)

Example result

{
  "match_score": 72.0,
  "matched_skills": ["Python", "FastAPI", "LLM", "RAG"],
  "missing_skills": ["MCP", "Docker", "Node.js"],
  "recommendations": [
    "Build an MCP server",
    "Learn Docker fundamentals",
    "Learn Node.js basics"
  ]
}

Next phases

  • Phase 2: connect an LLM and build an MCP client/agent

  • Phase 3: add FastAPI gateway

  • Phase 4: Docker Compose

  • Phase 5: evaluation and logging

  • Phase 6: GitHub polish + demo screenshots

Resume positioning

Suggested project title:

MCP-Based AI Resume & Job Analyzer | Python, MCP, FastAPI, LLM, Docker

Do not claim LLM integration or Docker deployment on the resume until those phases are actually implemented and tested.

Tool Schema Changelog

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

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server that evaluates, compares, aligns, generates, and validates resume materials against specific job postings, including ATS parseability checks, match scoring, and gap analysis.
      1
      Apache 2.0
    • A
      license
      A
      quality
      D
      maintenance
      Enables MCP clients to analyze resumes for ATS compatibility, parse job descriptions, get optimization and roast-style critiques, and generate tailored resumes with shareable preview links.
      6
      64 npm
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI clients to serve as a personal career analyst by searching, matching, and explaining job recommendations, managing job applications, and syncing public job boards through standardized MCP tools.
      MIT