Skip to main content
Glama
careerproof-mcp

careerproof-mcp

by detonnate

careerproof-mcp

Evidence-backed interview preparation through the Model Context Protocol.

CareerProof turns a candidate's real project history — GitHub repositories, a CV, and project notes — into interview preparation that is traceable to specific evidence: commits, pull requests, architecture docs, and dependency manifests. Every answer it helps produce distinguishes between:

  • Verified evidence — pulled directly from GitHub

  • Reasonable inference — evidence added manually, not independently verified

  • User-provided claim — extracted from the candidate's own CV

  • Missing evidence — explicitly flagged, never silently invented

Why

Ask a connected MCP client:

Analyse this Solutions Architect job description and show me where my GitHub projects prove each requirement.

and get back a requirement-by-requirement match, each one backed by a cited source:

Job requirement

Match

Supporting evidence

Power Platform

Strong

CertMate workflow documentation

API architecture

Strong

REST integration and service-layer code

SQL

Strong

Database schema and stored procedures

CI/CD

Weak

GitHub Actions exists but deployment evidence is limited

Team leadership

Unproven

No evidence found in the supplied sources

See docs/demonstration.md for a full walkthrough and examples/sample-evidence-report.json for a complete sample response.

Related MCP server: PROTEUS MCP Server

Design principle: no LLM in v1

CareerProof deliberately does not call an LLM API. Job description parsing and requirement matching use bullet parsing, a curated keyword dictionary, and token-overlap scoring. STAR-answer generation builds a cited outline, not prose. The connected MCP client (Claude Desktop, VS Code Copilot, etc.) supplies the language reasoning on top of this server's structured, traceable evidence — which keeps the server cheap, private, and easy to self-host. See docs/architecture.md for the full rationale.

MCP primitives

Tools (11) — actions such as indexing repositories, analysing job descriptions, matching requirements, generating STAR outlines, and exporting a preparation pack:

careerproof_add_candidate_profile, careerproof_index_repository, careerproof_add_project_evidence, careerproof_analyse_job_description, careerproof_match_requirements, careerproof_find_evidence, careerproof_generate_star_answer, careerproof_find_evidence_gaps, careerproof_generate_interview_questions, careerproof_score_interview_answer, careerproof_export_preparation_pack

Resources (5) — read-only, application-controlled views:

careerproof://candidate/profile, careerproof://jobs/{jobId}, careerproof://projects/{projectId}, careerproof://evidence/{evidenceId}, careerproof://skills/matrix

Prompts (5) — reusable, host-surfaced workflows:

prepare_for_interview, create_star_answer, challenge_cv_claim, run_mock_technical_interview, identify_portfolio_gaps

Quick start

npm install
npm run build
npm start          # runs dist/server.js over stdio

Or run directly from source during development:

npm run dev

Try it with the MCP Inspector:

npx @modelcontextprotocol/inspector npx tsx src/server.ts

Register with an MCP host

Point your host at the built server (see mcp.json for a ready-made config):

{
  "mcpServers": {
    "careerproof": {
      "command": "node",
      "args": ["dist/server.js"],
      "env": { "CAREERPROOF_DB_PATH": "./data/careerproof.db" }
    }
  }
}

Environment variables

Variable

Purpose

Default

CAREERPROOF_DB_PATH

Path to the local SQLite database

./data/careerproof.db

GITHUB_TOKEN

Optional GitHub token for higher API rate limits / private repos

unset (public, unauthenticated)

Example tool call

{
  "tool": "careerproof_generate_star_answer",
  "arguments": {
    "competency": "Describe a time you designed a complex solution",
    "project": "CertMate EICR",
    "maximumWords": 250
  }
}
{
  "answer": {
    "situation": "...",
    "task": "...",
    "action": "...",
    "result": "..."
  },
  "confidence": 0.84,
  "evidence": [
    { "source": "docs/architecture.md", "lines": "18-42", "type": "verified" }
  ],
  "missingInformation": [
    "No measurable performance improvement was documented"
  ]
}

Repository structure

careerproof-mcp/
├── src/
│   ├── server.ts       # entry point (stdio transport)
│   ├── tools/           # 11 MCP tools
│   ├── resources/       # 5 MCP resources
│   ├── prompts/         # 5 MCP prompts
│   ├── github/          # GitHub REST client + repository indexer
│   ├── evidence/        # CV parsing, evidence store, export pack
│   ├── matching/         # requirement extraction, matching, STAR/gap/question logic
│   └── database/        # Drizzle schema + SQLite client
├── examples/             # sample CV, job description, evidence report
├── evals/                 # judgement evals for the matching logic
├── tests/                # Vitest unit + MCP protocol tests
├── docs/                 # architecture, threat model, demonstration walkthrough
├── Dockerfile
├── mcp.json
└── README.md

Development

npm test              # vitest unit + protocol tests
npm run lint          # tsc --noEmit
npx tsx evals/requirement-matching.eval.ts   # judgement eval

Docker

docker build -t careerproof-mcp .
docker run -i -v careerproof-data:/data careerproof-mcp

The server speaks stdio, so docker run -i (interactive, no TTY) is how an MCP host would launch it as a subprocess.

Roadmap

  • Streamable HTTP transport + OAuth for a remotely-hosted deployment

  • Optional local embeddings for semantic evidence search

  • PDF CV import

Docs

License

MIT

Available Tools

11 tools
careerproof_add_candidate_profileAdd candidate profileA

Registers a candidate's CV (Markdown or plain text) and extracts individually-citable claims from it. Every extracted claim is stored with confidence 'user_claim' — it is what the candidate says about themselves, not independently verified.

Inputs: name (required), cvText (required), summary, headline.

careerproof_add_project_evidenceAdd manual project evidenceA

Manually attaches an evidence item to an indexed project (e.g. an architecture decision explained in conversation). Defaults to 'inferred' confidence since it wasn't pulled directly from a verifiable source.

Inputs: excerpt (required), projectId (required), lineEnd, filePath, +3 more.

careerproof_analyse_job_descriptionAnalyse a job descriptionA

Stores a pasted job description and extracts structured requirements (skills, tools, competencies) using bullet parsing and a curated keyword dictionary. No LLM is used here — the connected client can add further reasoning on top of these structured requirements.

Inputs: descriptionText (required), title.

careerproof_export_preparation_packExport interview preparation packB

Assembles the complete evidence-backed preparation pack for a job: requirement matches, evidence gaps, and generated interview questions. Returns either JSON or a Markdown report.

Inputs: jobId (required), format, candidateId.

careerproof_find_evidenceFind evidenceA

Free-text search across all stored evidence (commits, pull requests, docs, dependency manifests, CV claims and manual notes). Every result carries its confidence tag (verified / inferred / user_claim / missing) so the caller knows how much to trust it.

Inputs: query (required), limit, projectId.

careerproof_find_evidence_gapsFind evidence gapsA

Re-runs requirement matching for a job and returns only the requirements with weak or unproven support, each with a concrete suggestion for what evidence to add.

Inputs: jobId (required), projectId, candidateId.

careerproof_generate_interview_questionsGenerate interview questionsB

Generates likely interview questions from a job's requirements, prioritising requirements with the weakest evidence so preparation time is spent where it matters most.

Inputs: jobId (required), count.

careerproof_generate_star_answerGenerate a cited STAR-answer outlineA

Builds a Situation/Task/Action/Result outline for a competency and project, scaffolded entirely from stored evidence (commits, PRs, docs). Never invents narrative detail: gaps are listed explicitly in 'missing_information' rather than filled in. The connected client should turn this outline into flowing prose.

Inputs: project (required), competency (required), maximumWords.

careerproof_index_repositoryIndex a GitHub repositoryB

Indexes a public (or token-accessible) GitHub repository: recent commits, pull requests, README/architecture docs, and dependency manifests. Everything pulled directly from GitHub is stored as 'verified' evidence because it is directly observed, not inferred.

Inputs: repoUrl (required), projectName (required), candidateId, commitLimit, +1 more.

careerproof_match_requirementsMatch job requirements to evidenceB

Scores every requirement extracted for a job against all stored evidence (indexed repositories and/or CV claims), returning a match strength (strong / moderate / weak / unproven) plus the specific evidence cited for each requirement.

Inputs: jobId (required), projectId, candidateId.

careerproof_score_interview_answerScore a practice interview answerA

Rule-based (non-LLM) check of a candidate's practice answer: STAR structure presence, first-person action verbs, measurable results, length vs. a target word count, and keyword relevance to the target competency. Returns a score and specific, actionable feedback rather than a black-box grade.

Inputs: answerText (required), competency, questionId, maximumWords.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 11 tools

    Disambiguation5/5

    Each tool has a clearly distinct role: evidence ingestion (profile, repository, manual), analysis (job description, matching, gaps, scoring), generation (STAR, questions), and export. Potential confusion between find_evidence, find_evidence_gaps, and match_requirements is resolved by descriptions specifying search vs. gap-only vs. scoring. No two tools appear interchangeable.

    Naming Consistency5/5

    All 11 tools use a consistent `careerproof_` prefix followed by snake_case verb_noun construction (add_, index_, score_, export_, find_, analyse_, match_, generate_). The pattern is predictable and readable. Only minor variance is verb choice (analyse vs. analyze) but not inconsistent.

    Tool Count5/5

    11 tools is well-scoped for a career-evidence preparation server, covering ingestion, analysis, generation, and export without obvious bloat. Each tool earns its place by handling a distinct workflow step. Falls squarely within the ideal 3-15 range.

    Completeness4/5

    Core lifecycle is covered: ingest evidence (CV, repo, manual), analyze job requirements, match against evidence, identify gaps, generate answers/questions, and export a pack. Minor gaps exist for updating/deleting evidence items or profiles, but these are not critical for the stated prep workflow. Agent can work around via re-ingestion or new evidence.

    Maintenance

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • 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
      57 npm
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables LLM clients to analyse job postings, tailor resumes from an evidence-labelled profile, validate every claim against that profile, and track applications, all through deterministic MCP tools.
      7
      Apache 2.0