Skip to main content
Glama
AndreaCadonna

Resume Generator MCP Server

by AndreaCadonna
OverviewSchemaRelated ServersScoreDiscussions
JavaScript
Hybrid

Resume Generator MCP Server (Discontinued)

IMPORTANT

This MCP server is no longer maintained. Resumake and the hosted resume-rendering service used by this project have been discontinued, so this implementation can no longer generate PDFs through its original endpoint.

The working resume-tailoring and rendering logic has moved to the tailor-resume skill. The skill runs the original Resumake v2 LaTeX generators locally, supports all nine templates, and does not depend on the discontinued hosted endpoint.

For new installations and usage instructions, use the maintained skill repository:

AndreaCadonna/skills - tailor-resume

Archived MCP documentation

The documentation below is retained for historical and migration reference. Commands and examples that call the LaTeX Resume API are no longer operational.

A Model Context Protocol (MCP) server that generates professional PDF resumes using LaTeX templates. Integrates seamlessly with Claude Desktop to create polished resumes from structured data with advanced folder management and organization features.

Resume Generator License

Related MCP server: LaTeX Resume MCP

Features

  • šŸŽØ 9 Professional Templates - Powered by high-quality LaTeX designs

  • šŸ“„ PDF Generation - Professional-grade output via LaTeX Resume API

  • šŸ”§ MCP Integration - Works directly with Claude Desktop

  • šŸ“ Structured Data - Easy-to-use JSON schema for resume data

  • šŸŽÆ Customizable - Custom headings, sections, and template selection

  • šŸ’¼ Professional Quality - LaTeX-based rendering for crisp, professional results

  • šŸ¤– AI-Powered - Natural language resume creation through Claude

  • šŸ“ Folder Management - Create custom folders and organize resumes by job, company, or category

  • šŸ—‚ļø Directory Navigation - List and browse your resume collection with built-in file explorer

  • šŸ›”ļø Secure Paths - Built-in path sanitization prevents security issues

Overview

This MCP server acts as a bridge between Claude Desktop and professional resume generation. Simply describe your resume requirements in natural language to Claude, and it will generate a beautifully formatted PDF resume using LaTeX templates. Now with advanced organization features to keep your resumes perfectly organized!

Prerequisites

  • Node.js (v16 or higher)

  • Claude Desktop application

  • Internet connection (for LaTeX Resume API)

Installation

  1. Clone the repository:

    git clone https://github.com/yourusername/resume-generator-mcp.git
cd resume-generator-mcp

  2. Install dependencies:

    npm install

  3. Configure Claude Desktop: Add the following to your Claude Desktop MCP settings file:

    Windows: %APPDATA%\Claude\claude_desktop_config.json macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Linux: ~/.config/Claude/claude_desktop_config.json

    {
  "mcpServers": {
    "resume-generator": {
      "command": "node",
      "args": ["path/to/resume-generator-mcp/server.js"]
    }
  }
}

  4. Restart Claude Desktop to load the MCP server.

Usage

Once configured, you can use the resume generator directly in Claude Desktop with natural language. The tool is designed to be flexible and intelligent - you can provide your complete work history and let Claude craft the perfect resume for any situation.

How It Works

  1. Share Your Experience - Provide Claude with your complete professional background, education, skills, and achievements

  2. Specify Your Target - Optionally include a job description or mention the type of role you're targeting

  3. Organize Your Resumes - Choose where to save each resume with custom folder structures

  4. Get Tailored Results - Claude will automatically select and highlight the most relevant experiences for your specific goal

Example Requests

Basic Resume Generation

Create a resume for a software engineer with 5 years experience in React and Node.js

Organized Resume with Custom Folder

Generate a resume for a Senior Developer position at Google and save it in a "FAANG-applications/google" folder

Personal History + Target Position + Organization

Here's my background:
- 8 years as a software developer
- Worked at: Microsoft (2018-2021), Google (2021-2023), startup CTO (2023-present)
- Skills: Python, JavaScript, AWS, team leadership, architecture design
- Education: MS Computer Science from MIT
- Led teams of 5-15 people, built systems serving millions of users

I'm applying for this Senior Engineering Manager position at Netflix:
[paste job description here]

Generate a resume that highlights my most relevant experience for this role and save it in "streaming-companies/netflix" folder.

Folder Management

Create a folder structure for organizing my job applications: "job-search-2024/tech-companies" and "job-search-2024/startups"
Show me what resumes I have in my "tech-companies" folder

Template-Specific Generation with Organization

Generate a resume using template 3 for John Doe and save it in the "personal/drafts" folder with the filename "john-doe-senior-dev"

Career Pivot Scenarios with Organization

I have 10 years in finance but want to transition to product management. Here's my experience:
[detailed background]

Create a resume that emphasizes my transferable skills for a Product Manager role at a tech company and save it in "career-transition/product-management" folder.

Smart Organization Features

  • šŸ—‚ļø Auto-Folder Creation - Folders are created automatically when generating resumes

  • šŸ“ Custom Directory Structure - Organize by company, role type, industry, or any system that works for you

  • šŸ” Directory Browser - List contents of any folder to see your resume collection

  • šŸ“Š File Information - View file sizes, creation dates, and organize by metadata

  • šŸ›”ļø Path Security - Built-in sanitization prevents directory traversal and invalid characters

Organization Examples

By Company:

  • applications/google/

  • applications/microsoft/

  • applications/amazon/

By Role Type:

  • roles/senior-engineer/

  • roles/tech-lead/

  • roles/manager/

By Industry:

  • industries/fintech/

  • industries/healthcare/

  • industries/gaming/

By Status:

  • drafts/

  • submitted/2024/

  • archived/old-versions/

Smart Tailoring Features

  • šŸŽÆ Relevance Optimization - Automatically prioritizes experiences that match the target role

  • šŸ“ˆ Achievement Highlighting - Emphasizes quantifiable results and accomplishments

  • šŸ”„ Skill Alignment - Matches your skills to job requirements when provided

  • šŸ“ Professional Formatting - Ensures consistent, ATS-friendly formatting

  • šŸŽØ Template Selection - Recommends the best template for your industry/role

Claude will automatically structure your information and generate a professional PDF resume tailored to your specific goals, saving it exactly where you want it.

API Reference

Tools Available

generate_resume

Generates a PDF resume from structured data with optional folder organization.

Parameters:

  • resumeData (object): Complete resume information

  • filename (string, optional): Custom filename for the PDF

  • folderPath (string, optional): Custom folder path within generated-resumes directory

Example:

{
  "resumeData": {
    /* resume data */
  },
  "filename": "john-doe-senior-engineer",
  "folderPath": "job-applications/tech-companies/google"
}

create_folder

Creates a new folder within the generated-resumes directory.

Parameters:

  • folderPath (string): Folder path to create (supports nested folders)

Example:

{
  "folderPath": "applications/2024/q1"
}

list_folders

Lists all folders and files in the generated-resumes directory.

Parameters:

  • path (string, optional): Specific subdirectory to list

Example:

{
  "path": "applications/tech-companies"
}

create_resume_template

Creates a template structure with placeholder data.

Parameters:

  • templateNumber (integer, 1-9): Template to use as base

Resume Data Structure

{
  "selectedTemplate": 1,
  "basics": {
    "name": "John Doe",
    "email": "john.doe@example.com",
    "phone": "+1-555-0123",
    "website": "https://johndoe.dev",
    "location": {
      "address": "San Francisco, CA"
    }
  },
  "work": [
    {
      "company": "Tech Corp",
      "position": "Software Engineer",
      "location": "San Francisco, CA",
      "startDate": "2022",
      "endDate": "Present",
      "highlights": [
        "Developed web applications using React and Node.js",
        "Led team of 3 developers on key projects"
      ]
    }
  ],
  "education": [
    {
      "institution": "University of California",
      "area": "Computer Science",
      "studyType": "Bachelor of Science",
      "startDate": "2018",
      "endDate": "2022",
      "location": "Berkeley, CA"
    }
  ],
  "skills": [
    {
      "name": "Frontend",
      "keywords": ["React", "TypeScript", "HTML5", "CSS3"]
    }
  ],
  "projects": [
    {
      "name": "Portfolio Website",
      "description": "Personal portfolio built with Next.js",
      "url": "https://johndoe.dev",
      "keywords": ["Next.js", "React", "Tailwind CSS"]
    }
  ]
}

Configuration

File Storage

Generated PDFs are saved to organized directories within:

  • Windows: %LOCALAPPDATA%\AnthropicClaude\app-{version}\generated-resumes\

  • macOS: ~/Library/Application Support/AnthropicClaude/app-{version}/generated-resumes/

  • Linux: ~/.local/share/AnthropicClaude/app-{version}/generated-resumes/

Directory Structure Example

generated-resumes/
ā”œā”€ā”€ applications/
ā”‚   ā”œā”€ā”€ google/
ā”‚   ā”‚   ā”œā”€ā”€ john-doe-swe-2024-06-30.pdf
ā”‚   ā”‚   ā””ā”€ā”€ john-doe-senior-2024-06-30.pdf
ā”‚   ā”œā”€ā”€ microsoft/
ā”‚   ā””ā”€ā”€ startups/
ā”œā”€ā”€ drafts/
ā”‚   ā””ā”€ā”€ work-in-progress-2024-06-30.pdf
ā””ā”€ā”€ templates/
    ā””ā”€ā”€ base-template-2024-06-30.pdf

Troubleshooting

Common Issues

  1. "Method not found" errors:

    • Ensure Claude Desktop is restarted after configuration

    • Check that the path in claude_desktop_config.json is correct

  2. Connection errors:

    • Verify internet connection

    • Check if the LaTeX Resume API is accessible

  3. PDF not generated:

    • Check the generated-resumes directory permissions

    • Ensure the directory exists and is writable

  4. Folder creation errors:

    • Verify write permissions in the generated-resumes directory

    • Check that folder paths don't contain invalid characters

  5. Path-related issues:

    • Folder paths are automatically sanitized for security

    • Invalid characters are replaced with underscores

    • Directory traversal attempts (../) are automatically blocked

Debug Mode

Enable debug logging by setting the environment variable:

DEBUG=resume-generator node server.js

Development

Project Structure

resume-generator-mcp/
ā”œā”€ā”€ server.js              # Main MCP server with folder management
ā”œā”€ā”€ package.json           # Dependencies and scripts
ā”œā”€ā”€ README.md              # This file
ā””ā”€ā”€ generated-resumes/     # Output directory (created automatically)
    ā””ā”€ā”€ [organized folders] # Custom folder structure

Dependencies

  • @modelcontextprotocol/sdk: MCP SDK for server implementation

  • node-fetch: HTTP client for API requests

  • fs/promises: File system operations for folder management

Security Features

  • Path Sanitization: Prevents directory traversal attacks

  • Input Validation: Validates folder paths and filenames

  • Scope Limiting: All operations are confined to the generated-resumes directory

  • Character Filtering: Removes or replaces invalid filesystem characters

Contributing

  1. Fork the repository

  2. Create a feature branch: git checkout -b feature-name

  3. Make your changes and test thoroughly

  4. Submit a pull request with a clear description

Credits

This project is built on top of several amazing open-source projects and services:

LaTeX Resume API

  • Service: latexresu.me - Professional LaTeX resume generation API

  • Credits: Thanks to the LaTeX Resume API team for providing the backend service that powers the PDF generation

LaTeX Templates

The beautiful resume templates are based on designs from resumake.io and the broader LaTeX community:

Technology Stack

  • MCP (Model Context Protocol) - Anthropic for the protocol specification

  • Claude Desktop - Integration platform for AI-powered tools

  • Node.js - Runtime environment for folder management and file operations

  • LaTeX - Document preparation system for high-quality typesetting

License

MIT Ā© Resume Generator contributors

Support

Changelog

v2.0.0 - Folder Management Update

  • āœØ NEW: Custom folder organization within generated-resumes directory

  • āœØ NEW: create_folder tool for creating organized directory structures

  • āœØ NEW: list_folders tool for browsing and managing resume collections

  • āœØ NEW: Enhanced generate_resume with folderPath parameter

  • šŸ›”ļø NEW: Path sanitization and security features

  • šŸ“Š NEW: File metadata display (size, date) in directory listings

  • šŸ—‚ļø NEW: Auto-creation of folder paths when generating resumes

  • šŸ“ NEW: Support for nested folder structures

  • šŸ” NEW: Directory navigation and file organization tools

v1.0.0

  • Initial release

  • Support for 9 LaTeX templates via LaTeX Resume API

  • Natural language resume generation through Claude Desktop

  • MCP server implementation with structured data support

  • Professional PDF output with customizable templates

Made with ā¤ļø for the Claude Desktop and MCP community

Available Tools

4 tools
create_folderC

Create a new folder within the generated-resumes directory for organizing resumes

ParametersJSON Schema
NameRequiredDescriptionDefault
folderPathYesFolder path to create within the generated-resumes directory. Can include nested folders. Example: 'job-applications/google' or 'personal-projects'

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool creates a folder, implying a write operation, but doesn't address permissions, error handling, or what happens if the folder already exists. This leaves significant behavioral gaps for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence contributes directly to understanding the tool's function, making it appropriately concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral aspects like permissions, error cases, or return values, which are crucial for an agent to use this tool effectively in context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already fully documents the single parameter. The description adds no additional parameter semantics beyond what's in the schema, such as format constraints or examples, meeting the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Create a new folder') and resource ('within the generated-resumes directory for organizing resumes'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_folders' beyond the creation aspect, which prevents a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, when not to use it, or how it relates to siblings like 'list_folders' or 'create_resume_template', leaving the agent without contextual usage cues.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

create_resume_templateC

Create a template resume structure with placeholder data that can be filled in

ParametersJSON Schema
NameRequiredDescriptionDefault
templateNumberNoTemplate number (1-10)

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It states 'create', implying a write operation, but doesn't disclose behavioral traits such as whether this requires permissions, if it's idempotent, what happens on conflicts, or the format of the output. This is a significant gap for a creation tool with zero annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action, though it could be slightly more structured by including key details like output format or usage context.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool involves creation (a mutation) with no annotations and no output schema, the description is incomplete. It lacks details on what the created template looks like, how it's stored, error conditions, or any behavioral context, making it inadequate for safe and effective use by an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the parameter 'templateNumber' documented as 'Template number (1-10)'. The description adds no additional meaning beyond this, such as explaining what each template number represents or how the placeholder data varies. Baseline 3 is appropriate since the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'create' and the resource 'template resume structure with placeholder data', making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'generate_resume' (which might create actual resumes vs. templates) or 'create_folder' (which creates folders rather than resume templates), so it misses full sibling differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'generate_resume' or 'create_folder'. It implies usage for creating templates but doesn't specify contexts, prerequisites, or exclusions, leaving the agent with minimal direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate_resumeC

Generate a resume PDF using the LaTeX Resume API. Provide resume data and get a professionally formatted PDF. Can save to custom folders within the generated-resumes directory.

ParametersJSON Schema
NameRequiredDescriptionDefault
resumeDataYesComplete resume data object
filenameNoOptional filename for the saved PDF (without extension)resume
folderPathNoOptional folder path within the generated-resumes directory. If not specified, saves to the root directory. If the folder doesn't exist, it will be created. Example: 'job-applications/google' or 'drafts'

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the tool can save to custom folders and create them if needed, which adds some context. However, it fails to disclose critical behavioral traits such as whether this is a read-only or mutation operation (implied mutation from 'Generate'), potential side effects (e.g., file creation), error handling, or performance considerations like rate limits. The description is too sparse for a tool that creates files.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately concise with two sentences that efficiently convey the core functionality and a key feature (folder saving). It is front-loaded with the main purpose. There is no wasted verbiage, though it could be slightly more structured by separating usage notes, but this is minor.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (3 parameters with nested objects, no output schema, and no annotations), the description is incomplete. It lacks details on output (e.g., what the PDF response looks like, error formats), behavioral expectations, and integration with sibling tools. For a tool that generates files and interacts with a directory structure, more context is needed to guide the agent effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents the three parameters (resumeData, filename, folderPath). The description adds minimal value beyond the schema: it implies that resumeData is used for PDF generation and mentions folderPath functionality ('saves to custom folders within the generated-resumes directory'). However, it doesn't provide additional semantic context, such as examples of resumeData structure or usage tips, resulting in a baseline score of 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Generate a resume PDF using the LaTeX Resume API' with the specific action 'Provide resume data and get a professionally formatted PDF.' It distinguishes from siblings like 'create_resume_template' by focusing on PDF generation rather than template creation. However, it doesn't explicitly differentiate from all siblings (e.g., 'create_folder' or 'list_folders'), keeping it from a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides minimal usage guidance: it mentions saving to custom folders but lacks explicit when-to-use instructions, prerequisites, or alternatives. For instance, it doesn't clarify when to use this tool versus 'create_resume_template' or how it relates to folder management tools like 'create_folder' and 'list_folders'. This leaves the agent with insufficient context for optimal tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_foldersC

List all folders and files in the generated-resumes directory to help with organization

ParametersJSON Schema
NameRequiredDescriptionDefault
pathNoOptional path within generated-resumes to list. If not specified, lists the root directory

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool lists items, implying a read-only operation, but does not address potential behavioral traits such as pagination, sorting, error handling, or whether it recursively lists subdirectories. This leaves significant gaps in understanding how the tool behaves beyond basic listing.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence that efficiently conveys the tool's purpose without unnecessary details. It is front-loaded with the core action and resource, making it easy to parse. However, it could be slightly more structured by separating purpose from usage context.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's low complexity (one optional parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks details on behavioral aspects and output format, which are important for a listing tool. The absence of an output schema means the description should ideally hint at return values, which it does not.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, with the parameter 'path' fully documented in the input schema. The description does not add any additional meaning or context beyond what the schema provides (e.g., it does not explain path formatting or constraints). With high schema coverage, the baseline score of 3 is appropriate, as the description does not compensate but also does not detract.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('List all folders and files') and target resource ('generated-resumes directory'), providing a specific verb+resource combination. However, it does not explicitly distinguish this tool from potential sibling tools like 'create_folder' or 'generate_resume', which serve different purposes (creation vs. listing).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description includes a purpose clause ('to help with organization'), which implies a general context but does not provide explicit guidance on when to use this tool versus alternatives. No when-not-to-use scenarios or specific prerequisites are mentioned, leaving usage decisions largely to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 4 tool updatesv1.0.0
    • First observedcreate_folder
    • First observedcreate_resume_template
    • First observedgenerate_resume
    • First observedlist_folders
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.5/5.0
Disambiguation5/5

Each tool has a distinct and non-overlapping purpose: create_folder handles folder creation, create_resume_template sets up templates, generate_resume produces PDFs, and list_folders provides directory listings. There is no ambiguity in tool selection as they target different aspects of the resume generation workflow.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern using snake_case: create_folder, create_resume_template, generate_resume, and list_folders. The naming is predictable and readable, with no deviations or mixed conventions.

Tool Count5/5

With 4 tools, the server is well-scoped for its purpose of resume generation and organization. Each tool earns its place by covering essential operations like folder management, template creation, PDF generation, and directory listing, avoiding bloat or thin coverage.

Completeness4/5

The tool set covers core resume generation workflows, including folder organization, template setup, and PDF creation. A minor gap exists in update or delete operations for folders or templates, but agents can likely work around this by recreating items as needed.

Maintenance

ActivitySlowing
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/AndreaCadonna/resumake-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server