How do I use cv-forge?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@cv-forge Generate a cover letter and CV for a data scientist position at Amazon" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

cv-forge

by thechandanbhagat

Overview Schema Related Servers Score Discussions

TypeScript

Local

CV Forge

Forge powerful, ATS-friendly CVs tailored to any job requirement.

An intelligent MCP (Model Context Protocol) server that analyzes job postings and crafts perfectly-matched CVs.

Features

Parse Job Requirements: Extract key skills, qualifications, email addresses, and hiring manager names from job postings
Generate Tailored CVs: Create customized CV content based on user profile and job requirements
Cover Letter Generation: Generate personalized cover letters tailored to specific job applications
Email Template Creation: Create professional email templates with automatic email address detection
Complete Application Packages: Generate CV, cover letter, and email template in one command
PDF by Default: Automatically generates professional PDF documents when no format is specified
Multiple Output Formats: Generate documents in PDF (default), HTML, Markdown, and text formats
Professional PDF Generation: Create publication-ready PDF documents with professional styling
ATS-Friendly: Optimized for Applicant Tracking Systems with proper keyword placement
Smart Contact Extraction: Automatically extracts email addresses and hiring manager names from job descriptions

Related MCP server: resume-mcp

Star History

Installation

Via npm (Recommended)

Install globally:

npm install -g cv-forge

Or install locally in your project:

npm install cv-forge

From Source

Clone this repository
Install dependencies:
```
npm install
```
Build the project:
```
npm run build
```

Usage

Connecting to Claude Desktop

To use this MCP server with Claude Desktop, you need to add it to your Claude configuration file.

Step 1: Install cv-forge

npm install -g cv-forge

Step 2: Find your Claude Desktop config file

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

Step 3: Add the MCP server to your config

For global installation, add this to your claude_desktop_config.json file:

{
  "mcpServers": {
    "cv-forge": {
      "command": "cv-forge"
    }
  }
}

Or if installed locally, specify the full path:

{
  "mcpServers": {
    "cv-forge": {
      "command": "node",
      "args": ["d:/TopSecret/cv-forge/build/index.js"],
      "cwd": "d:/TopSecret/cv-forge"
    }
  }
}

Step 4: (Optional) Add environment configuration

You can customize the server with environment variables:

{
  "mcpServers": {
    "cv-forge": {
      "command": "cv-forge",
      "env": {
        "DEFAULT_OUTPUT_PATH": "D:/CV",
        "PDF_BASE_FONT_SIZE": "12px",
        "PDF_LINE_HEIGHT": "1.4"
      }
    }
  }
}

Step 5: Restart Claude Desktop After adding the configuration, restart Claude Desktop application.

Step 6: Verify Connection In Claude Desktop, you should see the CV Forge tools available. You can ask Claude to use tools like:

"Parse this job posting for me"
"Generate a tailored CV based on my profile and this job"
"Save my CV as a PDF file"

Running the MCP Server Standalone (for testing)

You can also run the server directly for testing:

npm start

The server runs on stdio and communicates via the Model Context Protocol.

Available Tools

1. `parse_job_requirements`

Parses job requirements and extracts key information for CV tailoring.

Parameters:

jobTitle (string, required): The job title/position
company (string, required): Company name
jobDescription (string, required): Full job description text
requirements (array, optional): Specific requirements if separated
preferredSkills (array, optional): Preferred skills if separated
location (string, optional): Job location
salaryRange (string, optional): Salary range if provided

2. `generate_cv_data`

Generates tailored CV content based on user profile and job requirements.

Parameters:

userProfile (object, required): Complete user profile information
jobRequirements (object, required): Job requirements object

User Profile Structure:

{
  "personalInfo": {
    "fullName": "John Doe",
    "email": "john@example.com",
    "phone": "+1-555-0123",
    "location": "City, State",
    "linkedIn": "linkedin.com/in/johndoe",
    "github": "github.com/johndoe",
    "website": "johndoe.com"
  },
  "summary": "Professional summary text...",
  "experience": [
    {
      "jobTitle": "Software Engineer",
      "company": "Tech Corp",
      "location": "City, State",
      "startDate": "2020-01",
      "endDate": "2023-12",
      "description": "Job description...",
      "achievements": [
        "Achievement 1",
        "Achievement 2"
      ]
    }
  ],
  "education": [
    {
      "degree": "Bachelor of Science in Computer Science",
      "institution": "University Name",
      "location": "City, State",
      "graduationYear": "2020",
      "gpa": "3.8",
      "honors": ["Magna Cum Laude"]
    }
  ],
  "skills": {
    "technical": ["JavaScript", "Python", "React"],
    "soft": ["Leadership", "Communication"],
    "languages": ["English", "Spanish"],
    "certifications": ["AWS Certified"]
  },
  "projects": [
    {
      "name": "Project Name",
      "description": "Project description...",
      "technologies": ["React", "Node.js"],
      "url": "github.com/johndoe/project"
    }
  ]
}

3. `save_cv_text`

Saves CV content as a formatted text file.

Parameters:

cvData (object, required): Tailored CV data object (from generate_cv_data)
outputPath (string, required): Directory path where the CV should be saved
fileName (string, optional): Custom filename (without extension), defaults to "generated_cv"

4. `generate_cv` (Recommended - Main CV Generation Tool)

Generate tailored CV and save to specified location or default folder. Defaults to PDF format if no format is specified.

Parameters:

userProfile (object, required): Complete user profile information
jobRequirements (object, required): Job requirements object
outputPath (string, optional): Directory path where the CV should be saved (uses DEFAULT_OUTPUT_PATH if not provided)
fileName (string, optional): Custom filename (without extension), defaults to "professional_cv"
format (string, optional): Output format - "pdf" (default), "html", or "markdown"
pageSize (string, optional): PDF page size (e.g., 'A4', 'Letter', 'Legal') - uses PDF_PAGE_SIZE env var if not provided
margins (object, optional): PDF margins with top, right, bottom, left properties (e.g., '10mm', '0.8in') - uses PDF_MARGIN_* env vars if not provided

5. `generate_and_save_cv_pdf` (Legacy - Use generate_cv instead)

Generate tailored CV and save directly as professional PDF (combines CV generation and PDF creation in one step).

Parameters:

userProfile (object, required): Complete user profile information
jobRequirements (object, required): Job requirements object
outputPath (string, optional): Directory path where the CV should be saved (uses DEFAULT_OUTPUT_PATH if not provided)
fileName (string, optional): Custom filename (without extension), defaults to "professional_cv"

6. `generate_and_save_cv_markdown` (Recommended)

Generate tailored CV and save directly as Markdown (combines CV generation and Markdown creation in one step).

Parameters:

userProfile (object, required): Complete user profile information
jobRequirements (object, required): Job requirements object
outputPath (string, required): Directory path where the CV should be saved
fileName (string, optional): Custom filename (without extension), defaults to "cv_markdown"

7. `generate_and_save_cv_html` (Recommended)

Generate tailored CV and save directly as HTML (combines CV generation and HTML creation in one step).

Parameters:

userProfile (object, required): Complete user profile information
jobRequirements (object, required): Job requirements object
outputPath (string, required): Directory path where the CV should be saved
fileName (string, optional): Custom filename (without extension), defaults to "cv_html"

8. `generate_cv_pdf` (Advanced)

Generate and save CV as a professional PDF document from pre-generated CV data.

Parameters:

cvData (object, required): Tailored CV data object (from generate_cv_data)
outputPath (string, required): Directory path where the CV should be saved
fileName (string, optional): Custom filename (without extension), defaults to "professional_cv"

9. `generate_cv_markdown` (Advanced)

Generate CV as Markdown format from pre-generated CV data.

Parameters:

cvData (object, required): Tailored CV data object (from generate_cv_data)
outputPath (string, required): Directory path where the CV should be saved
fileName (string, optional): Custom filename (without extension), defaults to "cv_markdown"

10. `generate_cv_html` (Advanced)

Generate CV as styled HTML document from pre-generated CV data.

Parameters:

cvData (object, required): Tailored CV data object (from generate_cv_data)
outputPath (string, required): Directory path where the CV should be saved
fileName (string, optional): Custom filename (without extension), defaults to "cv_web"

Cover Letter and Email Template Tools

11. `generate_cover_letter` (Recommended)

Generate a tailored cover letter for a specific job application. Returns formatted text that can be displayed on screen or saved as PDF.

Parameters:

userProfile (object, required): Complete user profile information
jobRequirements (object, required): Job requirements object
hiringManagerName (string, optional): Name of the hiring manager if known
format (string, optional): Output format - "text" (default) for on-screen display, "html" for styled viewing

12. `save_cover_letter_pdf`

Generate and save a cover letter as PDF to specified location. Automatically extracts email addresses and hiring manager names from job descriptions.

Parameters:

userProfile (object, required): Complete user profile information
jobRequirements (object, required): Job requirements object
outputPath (string, optional): Directory path where the cover letter should be saved
fileName (string, optional): Custom filename (without extension), defaults to "cover_letter"
hiringManagerName (string, optional): Name of the hiring manager if known
pageSize (string, optional): PDF page size (e.g., 'A4', 'Letter', 'Legal')
margins (object, optional): PDF margins with top, right, bottom, left properties

13. `generate_email_template`

Generate a professional email template for job application. Automatically detects email addresses from job description.

Parameters:

userProfile (object, required): Complete user profile information
jobRequirements (object, required): Job requirements object
templateType (string, optional): Type of email template - "application" (default), "follow_up", "inquiry", "thank_you"
recipientEmail (string, optional): Recipient email address (optional, will use extracted email from job description if available)
hiringManagerName (string, optional): Name of the hiring manager if known

14. `draft_complete_application` (Recommended - One-Stop Solution)

Draft a complete job application package: CV, cover letter, and email template. Automatically generates PDF CV and cover letter, plus email template if email address is found in the job description.

Parameters:

userProfile (object, required): Complete user profile information
jobRequirements (object, required): Job requirements object
outputPath (string, optional): Directory path where files should be saved
baseFileName (string, optional): Base filename for generated files (without extension), defaults to "job_application"
hiringManagerName (string, optional): Name of the hiring manager if known

Configuration

Environment Variables

The MCP server supports various configuration options via environment variables in the Claude Desktop config:

{
  "mcpServers": {
    "cv-forge": {
      "command": "node",
      "args": ["path/to/cv-forge/build/index.js"],
      "cwd": "path/to/cv-forge",
      "env": {
        "DEFAULT_OUTPUT_PATH": "D:/CV",
        "TEMP_DIR": "C:/Users/YourName/AppData/Local/Temp/cv-maker",
        "PDF_TIMEOUT": "300000",
        "PDF_PAGE_SIZE": "A4",
        "PDF_MARGIN_TOP": "10mm",
        "PDF_MARGIN_RIGHT": "10mm",
        "PDF_MARGIN_BOTTOM": "10mm",
        "PDF_MARGIN_LEFT": "10mm",
        "PDF_BASE_FONT_SIZE": "12px",
        "PDF_LINE_HEIGHT": "1.4",
        "PDF_H1_FONT_SIZE": "20px",
        "PDF_H2_FONT_SIZE": "15px",
        "PDF_H3_FONT_SIZE": "13px",
        "PDF_PARAGRAPH_SPACING": "8px",
        "PDF_SECTION_SPACING": "12px"
      }
    }
  }
}

Configuration Options:

DEFAULT_OUTPUT_PATH: Default directory for saving CV files (when outputPath is not provided or is "./")
TEMP_DIR: Directory for temporary files during PDF generation
PDF_TIMEOUT: Timeout for PDF generation in milliseconds
PDF_PAGE_SIZE: Default PDF page size - defaults to 'A4'
- Common sizes: 'A4' (210×297mm), 'Letter' (8.5×11in), 'Legal' (8.5×14in)
PDF_MARGIN_*: PDF page margins (top, right, bottom, left) - defaults to '10mm'
PDF_BASE_FONT_SIZE: Base font size for CV body text (12px ≈ MS Word 9pt, 13px ≈ 10pt)
PDF_LINE_HEIGHT: Line height for text (1.4 recommended for compact layout)
PDF_H1_FONT_SIZE: Font size for name/title heading
PDF_H2_FONT_SIZE: Font size for section headings
PDF_H3_FONT_SIZE: Font size for job titles and subsections
PDF_PARAGRAPH_SPACING: Spacing between paragraphs
PDF_SECTION_SPACING: Spacing between major sections

Example Usage with Claude Desktop

Once connected to Claude Desktop, you can use natural language to interact with the CV maker:

1. Parse Job Requirements

"Can you parse this job posting for me:

Job Title: Senior Software Engineer
Company: TechCorp Inc
Description: We are looking for a Senior Software Engineer with 5+ years of experience in JavaScript, React, and Node.js. Must have experience with cloud platforms and agile methodologies. Strong communication skills required."

2. Generate Tailored CV (Simple One-Step Process - PDF by Default)

"Generate a tailored CV for me based on this job posting:

Job Title: Senior Software Engineer
Company: TechCorp Inc
Job Description: We are looking for a Senior Software Engineer with 5+ years of experience in JavaScript, React, and Node.js. Must have experience with cloud platforms and agile methodologies.

My Profile:
- Full Name: John Doe
- Email: john@example.com
- Phone: +1-555-0123
- Experience: 6 years as Software Engineer at various companies
- Skills: JavaScript, Python, React, Node.js, AWS, Docker
- Education: BS Computer Science from State University

Please save it to C:\Users\John\Documents\CVs with filename 'john_doe_senior_engineer_techcorp'"

Note: This will automatically generate a PDF file (default format) unless you specify a different format.

3. Generate Different Formats

"Can you generate my CV in multiple formats? I need:
1. A professional PDF for applications (default format)
2. A Markdown version for my GitHub  
3. An HTML version for my website

Save them all to C:\Users\John\Documents\CVs with the base filename 'john_doe_cv'"

Or specify format explicitly:

"Generate my CV in HTML format and save it to C:\Users\John\Documents\CVs"

Or specify custom page size and margins for PDF:

"Generate my CV as a PDF with Letter page size and 1 inch margins on all sides, save it to C:\Users\John\Documents\CVs"

3. Generate Cover Letters

"Generate a cover letter for the Senior Software Engineer position at TechCorp Inc. The job description mentions the hiring manager is Sarah Johnson and applications should be sent to careers@techcorp.com."

4. Generate Email Templates

"Create an email template for applying to the Senior Software Engineer position at TechCorp Inc. The job posting includes the email careers@techcorp.com and mentions Sarah Johnson as the hiring manager."

5. Draft Complete Application Package (Recommended)

"Draft a complete job application package for the Senior Software Engineer position at TechCorp Inc. Include CV, cover letter, and email template. Save everything to C:\Users\John\Documents\Applications with the base filename 'techcorp_application'."

This will generate:

techcorp_application_CV.pdf - Tailored CV
techcorp_application_Cover_Letter.pdf - Professional cover letter
techcorp_application_Email_Template.txt - Email template (if email address found in job description)

6. Generate Follow-up Email Template

"Generate a follow-up email template for the Senior Software Engineer position I applied to at TechCorp Inc last week."

7. Direct Tool Usage Examples

If you want to use the tools directly (advanced usage):

Parse a job posting:

{
  "tool": "parse_job_requirements",
  "args": {
    "jobTitle": "Senior Software Engineer",
    "company": "TechCorp Inc",
    "jobDescription": "We are looking for a Senior Software Engineer with 5+ years of experience in JavaScript, React, and Node.js. Must have experience with cloud platforms and agile methodologies."
  }
}

Generate tailored CV:

{
  "tool": "generate_cv_data", 
  "args": {
    "userProfile": { /* user profile object */ },
    "jobRequirements": { /* job requirements object */ }
  }
}

Generate PDF CV:

{
  "tool": "generate_cv_pdf",
  "args": {
    "cvData": { /* tailored CV data */ },
    "outputPath": "C:\\Users\\YourName\\Documents\\CVs",
    "fileName": "senior_engineer_techcorp_cv"
  }
}

Generate Markdown CV:

{
  "tool": "generate_cv_markdown",
  "args": {
    "cvData": { /* tailored CV data */ },
    "outputPath": "C:\\Users\\YourName\\Documents\\CVs",
    "fileName": "cv_for_github"
  }
}

Generate HTML CV:

{
  "tool": "generate_cv_html",
  "args": {
    "cvData": { /* tailored CV data */ },
    "outputPath": "C:\\Users\\YourName\\Documents\\CVs",
    "fileName": "web_resume"
  }
}

Save CV as text file:

{
  "tool": "save_cv_text",
  "args": {
    "cvData": { /* tailored CV data */ },
    "outputPath": "C:\\Users\\YourName\\Documents\\CVs",
    "fileName": "senior_engineer_techcorp_cv"
  }
}

How It Works

Job Analysis: The server parses job descriptions to extract:
- Required technical skills
- Preferred qualifications
- Company industry and size
- Experience level requirements
CV Tailoring: Based on the analysis, it:
- Prioritizes relevant skills and experience
- Adjusts the professional summary
- Reorders and emphasizes matching achievements
- Incorporates job-specific keywords for ATS optimization
Output Generation: Creates a well-formatted text CV that:
- Uses ATS-friendly formatting
- Includes relevant keywords
- Maintains professional structure
- Highlights the most relevant qualifications

File Structure

cv-forge/
├── src/
│   ├── index.ts                    # Main MCP server
│   └── lib/
│       ├── job-parser.ts           # Job requirement parsing logic
│       ├── cv-generator.ts         # CV tailoring algorithms
│       ├── document-generator.ts   # Multi-format document generation
│       └── word-generator.ts       # Word document generation (future)
├── build/                          # Compiled JavaScript files
├── package.json                    # Project configuration
├── tsconfig.json                   # TypeScript configuration
├── claude_desktop_config.example.json  # Example configuration
└── README.md                       # This file

Development

Building

npm run build

Starting Development Server

npm run dev

Project Structure

src/index.ts: Main MCP server with tool registration
src/lib/job-parser.ts: Parses job requirements, extracts key information, emails, and hiring manager names
src/lib/cv-generator.ts: Generates tailored CV content based on job requirements
src/lib/cover-letter-generator.ts: Generates personalized cover letters for job applications
src/lib/email-template-generator.ts: Creates professional email templates for various application scenarios
src/lib/document-generator.ts: Multi-format document generation (PDF, HTML, Markdown)
src/lib/word-generator.ts: (Future) Word document generation functionality

Troubleshooting

PDF not saving to configured location

Ensure DEFAULT_OUTPUT_PATH is set in your Claude Desktop config
Restart Claude Desktop after changing configuration
Check that the path exists or the application has permission to create it

Font size too large or small

Adjust PDF_BASE_FONT_SIZE in environment variables (12px ≈ 9pt, 13px ≈ 10pt MS Word)
Modify PDF_LINE_HEIGHT for tighter/looser spacing
Restart Claude Desktop after changes

PDF generation fails

Check that output directory exists and is writable
Verify TEMP_DIR path is valid
Ensure sufficient disk space

Custom page size not working

Ensure page size is a valid format (A4, Letter, Legal, A3, A5, etc.)
Check that the page size is supported by the PDF generator
Use standard page size names (case-sensitive)

Custom margins not applied

Use proper units: 'mm', 'cm', 'in', 'px', 'pt'
Example: '10mm', '0.8in', '72pt'
Restart Claude Desktop after changing environment variables

Future Enhancements

Enhanced Word document generation with advanced formatting
Multiple CV and cover letter templates (modern, classic, minimal)
Advanced keyword optimization algorithms
Integration with job boards for automatic job parsing
LinkedIn profile integration for automatic profile data
Interview preparation questions based on job requirements
Salary negotiation guidance based on market data
Multi-language support for international applications
AI-powered writing suggestions and improvements

Dependencies

@modelcontextprotocol/sdk: Core MCP functionality
zod: Schema validation and type safety
typescript: TypeScript compiler
md-to-pdf: PDF generation from Markdown
markdown-it: Markdown parsing and HTML conversion
docx: Word document generation (for future Word output)

License

This project is available under the MIT License.

Contributing

Contributions are welcome! Please feel free to submit pull requests or open issues for bugs and feature requests.

Available Tools

17 tools

debug_cv_dataB

Debug tool to inspect the structure of CV data

ParametersJSON Schema

Name	Required	Description	Default
`cvData`	No	Tailored CV data object to inspect

TDQS

B3.1/5.0

Behavior2/5

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

With no annotations, the description carries full burden for behavioral traits. It only states the tool is for debugging and inspection, but fails to disclose whether it has side effects, is read-only, or any other behaviors. The minimal description leaves significant ambiguity.

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 sentence, front-loaded with the key purpose. It is efficient with no wasted words. However, given the tool's specialized nature, a bit more detail could be justified without harming conciseness.

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?

The description is incomplete for a debug tool. It does not specify what 'inspect' entails (e.g., console output, return value), nor does it provide any usage context or expected behavior. Despite the tool's simplicity, important details are missing.

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 coverage is 100%, and the schema's parameter description ('Tailored CV data object to inspect') already conveys the parameter's role. The tool description adds no further meaning, so the baseline score of 3 is appropriate.

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

Purpose5/5

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

The description clearly states the tool is for inspecting the structure of CV data, using a specific verb ('inspect') and resource ('CV data structure'). It distinguishes itself from sibling tools which are primarily for generation and saving, making its role unique.

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?

No guidance is provided on when to use this tool versus alternatives. The description does not indicate any prerequisites, context, or scenarios where this tool is appropriate, leaving the agent without decision support.

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

draft_complete_applicationB

Draft a complete job application package: CV, cover letter, and email template. Automatically generates PDF CV and cover letter, plus email template if email address is found.

ParametersJSON Schema

Name	Required	Description
`outputPath`	No	Directory path where files should be saved (optional, uses DEFAULT_OUTPUT_PATH if not provided)
`userProfile`	Yes
`baseFileName`	No	Base filename for generated files (without extension)
`jobRequirements`	Yes
`hiringManagerName`	No	Name of the hiring manager if known

TDQS

B3.1/5.0

Behavior3/5

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

Description discloses automatic PDF generation and conditional email template creation based on email presence, but lacks details on side effects (file overwriting, default output path), error handling, or return behavior. No annotations provided to supplement.

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?

Two sentences efficiently convey purpose and key behavior (PDF generation, conditional email). Front-loaded with the main action. Could benefit from a brief usage hint but remains concise.

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 5 parameters (2 required), nested objects, no output schema, and 16 sibling tools, the description lacks completeness: no mention of return values, success/failure indicators, file naming conventions, or scenarios where email is missing. Leaves agent uncertain about outcomes.

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 60%, so parameters are partially documented in schema. The description adds minimal parameter-specific insight beyond 'email address is found,' not clarifying which schema field triggers email generation. No explanation of complex nested object usage.

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?

Description clearly states the tool drafts a complete application package (CV, cover letter, email template) and specifies outputs (PDFs). It distinguishes from siblings that generate individual components, though 'complete' implies comprehensiveness; however, no explicit differentiation from similar tools like generate_cv_pdf.

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?

No guidance on when to use this tool vs. individual siblings (e.g., generate_cv, generate_cover_letter). The description assumes the user wants a full package; no mention of scenarios where only partial generation is needed or prerequisites.

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

draft_cv_pdfC

Draft a tailored CV in PDF format for a specific job. This tool automatically generates a professional PDF CV without asking for format preferences.

ParametersJSON Schema

Name	Required	Description
`fileName`	No	Custom filename (without extension)
`outputPath`	No	Directory path where the CV should be saved (optional, uses DEFAULT_OUTPUT_PATH if not provided)
`userProfile`	Yes
`jobRequirements`	Yes

TDQS

C2.9/5.0

Behavior2/5

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

No annotations exist, so the description must fully disclose behavior. It mentions automatic generation and no format prompts but omits side effects like file saving, permission requirements, or what happens to existing files.

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?

Two sentences, no fluff, front-loaded with the primary action. Every word adds value.

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 complex tool with deep nested objects and no output schema, the description is too minimal. It doesn't explain what the tool returns (e.g., file path), prerequisites, or how 'tailored' is achieved.

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 coverage is 50% (only fileName and outputPath have descriptions). The tool description adds no additional context for userProfile or jobRequirements, relying solely on the schema structure. Baseline score of 3 applies.

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 drafts a tailored CV in PDF format for a specific job, emphasizing it doesn't ask for format preferences. However, it does not explicitly differentiate from sibling tools like generate_cv_pdf or generate_and_save_cv_pdf.

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?

No guidance on when to use this tool over alternatives. With many similar sibling tools (e.g., generate_cv_pdf, generate_cv_html), the lack of usage context forces the AI to guess.

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

generate_and_save_cv_htmlB

Generate tailored CV and save directly as HTML (combines CV generation and HTML creation in one step)

ParametersJSON Schema

Name	Required	Description
`fileName`	No	Custom filename (without extension)
`outputPath`	Yes	Directory path where the CV should be saved
`userProfile`	Yes
`jobRequirements`	Yes

TDQS

B3.2/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 burden. It only states 'save directly as HTML' but omits behavioral traits like file overwriting, permission needs, error handling, or side effects.

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 concise with a single sentence covering the main purpose. However, it is slightly run-on and could benefit from clearer structure, but it contains no extraneous content.

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 (4 params, nested objects, no output schema, many siblings), the description is too brief. It does not explain return values, error scenarios, or how 'tailored' works, leaving the agent with insufficient context.

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

Parameters2/5

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

Schema description coverage is 50%, and the description adds no parameter-specific information. It does not explain the meaning or usage of any parameters beyond what the schema already contains.

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

Purpose5/5

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

The description clearly states the verb (generate and save), the resource (CV HTML), and that it combines two steps in one. It distinguishes from siblings like generate_cv_html and generate_and_save_cv_markdown.

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

Usage Guidelines3/5

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

The description implies usage (for generating and saving CV as HTML in one step) but does not provide explicit guidance on when to use this tool versus alternatives or when not to use it.

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

generate_and_save_cv_markdownC

Generate tailored CV and save directly as Markdown (combines CV generation and Markdown creation in one step)

ParametersJSON Schema

Name	Required	Description
`fileName`	No	Custom filename (without extension)
`outputPath`	Yes	Directory path where the CV should be saved
`userProfile`	Yes
`jobRequirements`	Yes

TDQS

C2.9/5.0

Behavior2/5

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

The tool saves to a file, but the description does not disclose behaviors such as whether it overwrites existing files, what happens on error, or any required permissions. No annotations are present to compensate. The description adds minimal transparency beyond 'save directly as Markdown'.

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 sentence that is front-loaded with the main action. It is concise with no filler, but could be more structured with bullet points or separate clauses to improve readability. However, it earns its minimal word count.

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 (nested objects, 4 parameters, no output schema), the one-sentence description is inadequate. It does not explain what constitutes a 'tailored CV', how the userProfile and jobRequirements are used, the expected output format details, or any side effects. The description lacks completeness for an AI agent to understand the tool's full behavior.

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

Parameters2/5

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

Schema description coverage is 50%, and the description provides no additional explanation of the parameters (userProfile, jobRequirements, outputPath, fileName). It does not compensate for the missing parameter descriptions or explain how the parameters influence the output.

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 generates a tailored CV and saves it as Markdown, using specific verbs ('generate', 'save') and resource ('CV', 'Markdown'). It distinguishes from siblings like generate_cv_markdown (no save) and generate_and_save_cv_html (different format). However, it does not explicitly mention tailoring to job requirements, though implied by parameters.

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

Usage Guidelines3/5

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

The description implies use when you want to both generate and save a CV in Markdown format in one step. It does not explicitly state when to use versus alternatives like generate_cv_markdown (for generation only) or generate_and_save_cv_html (for HTML). No exclusions or prerequisites provided.

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

generate_and_save_cv_pdfA

Generate tailored CV and save specifically as PDF format (legacy tool - consider using 'generate_cv' which defaults to PDF). If outputPath is not provided, uses DEFAULT_OUTPUT_PATH from environment.

ParametersJSON Schema

Name	Required	Description
`margins`	No	PDF margins - uses PDF_MARGIN_* env vars if not provided
`fileName`	No	Custom filename (without extension)
`pageSize`	No	PDF page size (e.g., 'A4', 'Letter', 'Legal') - uses PDF_PAGE_SIZE env var if not provided
`outputPath`	No	Directory path where the CV should be saved (optional, uses DEFAULT_OUTPUT_PATH if not provided)
`userProfile`	Yes
`jobRequirements`	Yes

TDQS

A3.8/5.0

Behavior3/5

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

No annotations are provided, so the description must carry the burden. It notes the legacy status and the default output path, but does not disclose other behaviors such as overwrite behavior, return format, or permission requirements.

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 concise at two sentences, front-loading the key action and legacy warning. No unnecessary words. It is structured efficiently.

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?

The tool has nested parameters and no output schema, but the description does not explain the return value (e.g., file path, success status). With sibling tools, the legacy distinction helps but the description could be more complete regarding tool behavior and output.

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 67%, so the schema already documents most parameters. The description adds value only for the outputPath parameter (default path). No further parameter semantics are explained beyond the schema.

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

Purpose5/5

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

The description clearly states the action: generate a tailored CV and save as PDF. It also identifies itself as a legacy tool and points to an alternative ('generate_cv'), helping distinguish it from siblings.

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

Usage Guidelines4/5

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

The description provides explicit guidance by labeling the tool as legacy and recommending 'generate_cv' instead. It also mentions the default behavior for outputPath. However, it does not elaborate on when specifically to use this tool over others.

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

generate_cover_letterC

Generate a tailored cover letter for a specific job application. Returns formatted text that can be displayed on screen or saved as PDF.

ParametersJSON Schema

Name	Required	Description	Default
`format`	No	Output format (text for on-screen display, html for styled viewing)	text
`userProfile`	Yes
`jobRequirements`	Yes
`hiringManagerName`	No	Name of the hiring manager if known

TDQS

C2.9/5.0

Behavior3/5

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

With no annotations, the description provides minimal behavioral info: it returns formatted text displayable or savable as PDF. It does not disclose side effects, authentication needs, or rate limits, but implies a read-only generation.

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 very concise (one sentence) and front-loads the primary action. It could include a brief note about required parameters without sacrificing conciseness.

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 complexity of the input schema (nested objects, multiple required fields) and no output schema, the description is insufficient. It does not explain how the cover letter is tailored or what to expect in the output, leaving the agent without key context.

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

Parameters2/5

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

The description does not clarify the complex userProfile and jobRequirements parameters. Schema coverage is only 50%, so the description should compensate but fails to explain how these objects influence the output.

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 it generates a tailored cover letter for a specific job application, distinguishing it from sibling tools that focus on CV generation or saving. However, it lacks specificity about the tailoring mechanism.

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?

No guidance on when to use this tool versus alternatives like generate_email_template or parse_job_requirements. No prerequisites or context for invocation.

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

generate_cvA

Generate tailored CV in PDF format and save to specified location or default folder. Always generates PDF unless a different format is explicitly requested.

ParametersJSON Schema

Name	Required	Description	Default
`format`	No	Output format - automatically set to PDF, only specify if you want HTML or Markdown instead	pdf
`margins`	No	PDF margins - uses PDF_MARGIN_* env vars if not provided
`fileName`	No	Custom filename (without extension)
`pageSize`	No	PDF page size (e.g., 'A4', 'Letter', 'Legal') - uses PDF_PAGE_SIZE env var if not provided
`outputPath`	No	Directory path where the CV should be saved (optional, uses DEFAULT_OUTPUT_PATH if not provided)
`userProfile`	Yes
`jobRequirements`	Yes

TDQS

A3.5/5.0

Behavior3/5

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

No annotations provided, so description carries burden. It mentions tailoring and always generating PDF unless other format requested, but lacks details on side effects (overwriting), permissions, or error handling.

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?

Two concise sentences front-load the core purpose and behavior. No extraneous information.

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?

The tool is complex with nested required objects, no output schema. Description is adequate but lacks details on the tailoring process, return values, or handling of optional parameters.

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 coverage is high (71%), so baseline is 3. The description adds minimal parameter meaning beyond the schema, e.g., 'specified location or default folder' for outputPath.

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

Purpose5/5

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

The description clearly states the tool generates a tailored CV and saves it to a specified location or default folder. It distinguishes from format-specific siblings by allowing format selection via the 'format' parameter with a PDF default.

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?

No guidance on when to use this tool versus the many similar siblings (e.g., generate_and_save_cv_pdf). The description does not specify prerequisites or when not to use it.

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

generate_cv_dataC

Generate tailored CV content based on user profile and job requirements (returns structured data)

ParametersJSON Schema

Name	Required	Description	Default
`userProfile`	Yes
`jobRequirements`	Yes

TDQS

C2.7/5.0

Behavior2/5

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

With no annotations, the description must disclose behavioral traits. It states it 'generates' content, implying a non-destructive operation, but does not clarify side effects, permissions needed, or whether the output is persisted. The return of 'structured data' is mentioned but no details on the output format or size limits.

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

Conciseness3/5

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

The description is a single sentence and a parenthetical, which is concise but lacks depth. It is not overly verbose, but it could pack more useful information without becoming long. The structure is flat and front-loaded with the main action.

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 complexity of the input schema (deeply nested objects with many required fields) and no output schema or annotations, the description is severely incomplete. It does not explain the expected output structure, behavior on errors, or how the tailoring works, leaving critical gaps for an agent.

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

Parameters1/5

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

Schema description coverage is 0%, yet the description adds no meaning beyond 'user profile and job requirements'. The complex nested structure of both parameters is completely undocumented, leaving the agent to infer all details from the schema alone, which is insufficient for correct invocation.

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

Purpose5/5

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

The description clearly states the verb 'Generate', the resource 'CV content', and the tailoring criteria 'based on user profile and job requirements'. It distinguishes from siblings by noting it 'returns structured data', which sets it apart from tools that generate specific formats like PDF or HTML.

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 the many siblings (e.g., generate_cv, generate_cv_html). It does not mention prerequisites, exclusions, or intended use cases, leaving the agent without context for selection.

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

generate_cv_htmlB

Generate CV as styled HTML document for web viewing

ParametersJSON Schema

Name	Required	Description
`cvData`	No	Tailored CV data object
`fileName`	No	Custom filename (without extension)
`outputPath`	Yes	Directory path where the CV should be saved

TDQS

B3/5.0

Behavior2/5

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

No annotations provided, so description carries full burden. It fails to disclose whether the tool overwrites files, required permissions, or output details beyond being 'styled HTML'.

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

Conciseness3/5

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

The description is a single concise sentence, but it could be more structured to include additional context without becoming verbose.

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 three parameters and no output schema, the description lacks details about how cvData should be structured, what the HTML output contains, and differentiation from siblings. Incomplete for informed selection.

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 coverage is 100% with descriptions for all three parameters. The tool description adds no extra meaning beyond the schema, meeting the baseline but not exceeding it.

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

Purpose5/5

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

The description clearly states the tool generates a styled HTML document for web viewing, which is specific and distinguishes it from sibling tools like generate_cv_pdf and generate_cv_markdown.

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?

No guidance on when to use this tool versus alternatives such as PDF or markdown generators. Missing usage context and exclusion criteria.

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

generate_cv_markdownC

Generate CV as Markdown format for easy editing and version control

ParametersJSON Schema

Name	Required	Description
`cvData`	No	Tailored CV data object
`fileName`	No	Custom filename (without extension)
`outputPath`	Yes	Directory path where the CV should be saved

TDQS

C2.8/5.0

Behavior2/5

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

No annotations provided, so description must carry burden. It mentions 'easy editing and version control' but does not explicitly state that it saves a file, requires write permissions, or handles errors. The outputPath parameter implies a file write, but this is not confirmed in the description.

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

Conciseness3/5

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

Description is concise (single sentence) but lacks structure or front-loading of key information. It is not verbose, but could be more informative.

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 has 3 parameters, no output schema, and no annotations, the description is insufficient. It does not explain the return value, error behavior, or the expected structure of cvData. The file-saving behavior is only implicit.

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% (all three parameters described). The tool description adds no additional meaning beyond the schema, so baseline score of 3 is appropriate.

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?

Description clearly states the verb (Generate), resource (CV), and format (Markdown). However, there is a sibling 'generate_and_save_cv_markdown' that is nearly identical, and the description does not differentiate itself.

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?

No guidance on when to use this tool versus alternatives like generate_cv_html or generate_cv_pdf. No context about prerequisites or preferred scenarios.

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

generate_cv_pdfC

Generate and save CV as a professional PDF document

ParametersJSON Schema

Name	Required	Description
`cvData`	No	Tailored CV data object
`margins`	No	PDF margins - uses PDF_MARGIN_* env vars if not provided
`fileName`	No	Custom filename (without extension)
`pageSize`	No	PDF page size (e.g., 'A4', 'Letter', 'Legal') - uses PDF_PAGE_SIZE env var if not provided
`outputPath`	Yes	Directory path where the CV should be saved

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 bears full responsibility for disclosing behavioral traits. It states it saves a PDF, implying disk writes, but does not disclose potential overwrites, required permissions, error handling, or any destructive aspects. This is insufficient for a file-writing 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, clear sentence with no wasted words. It is appropriately sized for the tool's purpose.

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?

Despite 100% schema coverage for parameters, the description is too brief for a tool with five parameters, nested objects, and environment variable defaults. It lacks an overview of the process, expected output, or behavioral details such as file naming conventions or confirmation of success. The lack of output schema further increases the need for descriptive completeness.

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 for all five parameters, including nested objects. The description adds no additional meaning beyond the schema, which already explains defaults via environment variables. Baseline 3 is appropriate as the schema does the work.

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 generates and saves a CV as a PDF document. It distinguishes itself from siblings that output HTML, Markdown, or text, but does not differentiate from sibling tools like 'draft_cv_pdf' or 'generate_and_save_cv_pdf', which appear to have overlapping purposes.

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 does not mention prerequisites, when not to use it, or how it compares to similar sibling tools like 'draft_cv_pdf' or 'generate_and_save_cv_pdf'.

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

generate_cv_to_default_folderB

Generate tailored CV and save to default folder (uses .env DEFAULT_OUTPUT_PATH). Defaults to PDF format.

ParametersJSON Schema

Name	Required	Description	Default
`format`	No	Output format (defaults to PDF)	pdf
`margins`	No	PDF margins - uses PDF_MARGIN_* env vars if not provided
`fileName`	No	Custom filename (without extension)
`pageSize`	No	PDF page size (e.g., 'A4', 'Letter', 'Legal') - uses PDF_PAGE_SIZE env var if not provided
`userProfile`	Yes
`jobRequirements`	Yes

TDQS

B3.3/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 full burden. It mentions saving to default folder via .env and default PDF format, but does not disclose whether files are overwritten, whether the folder must exist, or any other behavioral traits. Minimal transparency.

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 extremely concise with two short sentences, front-loaded with the primary action. No unnecessary words, ideal for quick parsing.

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 has 6 parameters including complex nested objects and no output schema, the description is too minimal. It fails to explain what 'tailored' means, how jobRequirements is used, or what the return value is. Important context for an agent to use correctly is missing.

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

Parameters2/5

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

Schema description coverage is 67%. The description only adds meaning for the format parameter (defaults to PDF), which is already stated in the schema default. It does not elaborate on complex nested objects like userProfile or jobRequirements, nor on margins, fileName, or pageSize.

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

Purpose5/5

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

The description clearly states the tool's function: generate a tailored CV and save to the default folder using an environment variable. The name also reinforces this purpose, distinguishing it from sibling tools that save to specific formats or without default path.

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

Usage Guidelines3/5

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

The description indicates default behavior (PDF format) but provides no explicit guidance on when to use this tool versus alternatives like generate_cv_pdf or generate_and_save_cv_pdf. Usage context is only implied by the name and description mention of default folder.

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

generate_email_templateC

Generate a professional email template for job application. Automatically detects email addresses from job description.

ParametersJSON Schema

Name	Required	Description	Default
`userProfile`	Yes
`templateType`	No	Type of email template	application
`recipientEmail`	No	Recipient email address (optional, will use extracted email from job description if available)
`jobRequirements`	Yes
`hiringManagerName`	No	Name of the hiring manager if known

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations, the description carries full burden but only mentions automatic email detection. It omits side effects, permissions, or limitations, leaving uncertainty about the tool's behavior.

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?

Two concise sentences, front-loaded with purpose. Efficient but could include more detail without becoming verbose.

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 5 parameters (including nested objects) and no output schema, the description is too brief. It does not cover template types, parameter usage hints, or return value, leaving significant gaps.

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

Parameters2/5

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

The description does not explain any parameters. Schema coverage is 60%, so some parameters have descriptions, but the description adds no additional meaning and does not compensate for missing schema details.

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

Purpose5/5

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

The description clearly states the tool generates a professional email template for job applications and highlights a specific feature (automatic email detection). It is distinct from sibling tools that focus on CVs and cover letters.

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?

No guidance on when to use this tool versus alternatives like generate_cover_letter. The description implies the purpose but does not provide explicit usage context or exclusions.

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

parse_job_requirementsC

Parse job requirements and extract key information for CV tailoring

ParametersJSON Schema

Name	Required	Description
`company`	Yes	Company name
`jobTitle`	Yes	The job title/position
`location`	No	Job location
`salaryRange`	No	Salary range if provided
`requirements`	No	Specific requirements if separated
`jobDescription`	Yes	Full job description text
`preferredSkills`	No	Preferred skills if separated

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 only states the action ('parse') without detailing whether the operation is read-only, idempotent, or has side effects. No information about authentication requirements, rate limits, or data persistence is given.

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, concise sentence (11 words) that conveys the core purpose without redundancy. It is front-loaded and efficient, though it could benefit from a second sentence to add context without losing conciseness.

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 has 7 parameters (3 required) and no output schema, the description lacks important context such as what 'key information' includes, how parsing works, or what the output looks like. This inadequacy hinders an agent's ability to fully understand the tool's capabilities and expectations.

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 input schema already documents all parameters. The description adds no additional meaning or context beyond what the schema provides. The baseline for high coverage is 3, and no extra param insights are offered.

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 'parse' and the resource 'job requirements', with the goal of 'extracting key information for CV tailoring'. It is distinct from sibling tools that focus on generating or saving CV documents, making the purpose clear and well-differentiated.

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 its siblings, such as 'generate_cv' or 'debug_cv_data'. There are no explicit conditions, prerequisites, or indications of workflow placement, leaving the agent to infer usage solely from the name.

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

save_cover_letter_pdfC

Generate and save a cover letter as PDF to specified location

ParametersJSON Schema

Name	Required	Description
`margins`	No	PDF margins - uses PDF_MARGIN_* env vars if not provided
`fileName`	No	Custom filename (without extension)
`pageSize`	No	PDF page size (e.g., 'A4', 'Letter', 'Legal') - uses PDF_PAGE_SIZE env var if not provided
`outputPath`	No	Directory path where the cover letter should be saved (optional, uses DEFAULT_OUTPUT_PATH if not provided)
`userProfile`	Yes
`jobRequirements`	Yes
`hiringManagerName`	No	Name of the hiring manager if known

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations, the description must disclose behavioral traits. It does not mention side effects (e.g., file overwriting), dependency on environment variables (margin/page size defaults), or response behavior. The schema provides some detail but the description itself is silent.

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

Conciseness3/5

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

The description is a single concise sentence, which is efficient but lacks structure. It does not use bullets or separate sections, making it less scannable. However, it is not overly verbose.

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 (7 parameters, nested objects, no output schema), the description is too minimal. It does not explain the output file naming, overwrite behavior, or error handling. The schema carries the informational burden, but the description should offer higher-level context.

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

Parameters2/5

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

Schema coverage is 71%, but the description adds no meaning beyond the schema. Parameter details like margins, pageSize, and outputPath are documented in the schema, but the description does not explain their purpose or relationship to the tool's operation.

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

Purpose5/5

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

The description clearly states 'Generate and save a cover letter as PDF to specified location', specifying the action (generate and save), resource (cover letter), format (PDF), and destination. It distinguishes from siblings like generate_cover_letter (text only) and generate_cv_pdf (CV PDF).

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, no prerequisites, and no indication of when not to use it. It relies entirely on the schema for required parameters without explicit usage context.

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

save_cv_textC

Save CV content as a text file to specified location

ParametersJSON Schema

Name	Required	Description
`cvData`	No	Tailored CV data object
`fileName`	No	Optional custom filename (without extension)
`outputPath`	Yes	Directory path where the CV should be saved

TDQS

C2.9/5.0

Behavior2/5

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

No annotations are provided, and the description does not disclose whether the tool overwrites existing files, requires write permissions, or returns a status. Minimal behavioral detail.

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?

Single concise sentence with no repetition. However, it could be more informative without increasing length significantly.

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?

No output schema; the description fails to mention return values or confirmations. Additionally, cvData lacks type specification, and the description does not compensate by explaining expected input format.

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 has 100% description coverage, so baseline is 3. Description does not add detail beyond schema, such as clarifying the expected structure of cvData or the naming behavior for fileName.

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?

Clearly states 'Save CV content as a text file' which specifies the verb, resource, and format. Differentiates from siblings that handle PDF, HTML, or Markdown formats.

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?

No guidance on when to use text format over other formats, or prerequisites such as requiring CV data to be generated first. Alternatives like generate_and_save_cv_html are not mentioned.

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

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

C2.7/5.0

Disambiguation2/5

Multiple tools serve the same purpose: generating a CV in PDF format (e.g., draft_cv_pdf, generate_cv, generate_cv_pdf, generate_cv_to_default_folder, generate_and_save_cv_pdf). These have unclear distinctions, causing high risk of misselection.

Naming Consistency2/5

Naming mixes verbs (generate, draft, save, debug, parse) and formats inconsistently. Some tools use 'generate_and_save_cv' while others use 'generate_cv' or 'draft_cv'. No consistent pattern.

Tool Count2/5

17 tools for a narrow domain (CV generation) is excessive. Many tools are redundant (e.g., 5+ PDF generation tools). The set could be consolidated to 5-8 distinct tools.

Completeness3/5

The set covers core needs: CV generation (multiple formats), cover letter, email template, and job requirement parsing. However, the redundancy suggests poor design, and there is no tool for updating or deleting generated content, though not strictly necessary.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

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

Related MCP Connectors

Vitex — AI Resume Generator
io.github.ChanMeng666
Generate tailored, ATS-optimized resume PDFs and cover letters from a job description, over MCP.
AI & Machine Learning Workplace & Productivity
2
nextrole A
io.github.hyperdrift-io
A job-search companion: tailor your CV to a role, score fit, fix ATS issues. Also via MCP.
Search Workplace & Productivity
52
getjobzi-mcp
io.github.getjobzi
GetJobzi MCP server for job search, application tracking, and career forecasting.
Search AI & Machine Learning
2
Caplia A
io.github.Caplia-Tech
MCP server for VC pitch-deck scoring, thesis-fit matching, and deal-flow management.
Finance AI & Machine Learning
2

Related MCP Servers

Resume Forge MCP
Workplace & Productivity
jitendrasinghsankhwar
A
license
A
quality
D
maintenance
An MCP server for intelligent LaTeX resume generation with multiple templates, quality scoring, and job description tailoring.
Updated 5 months ago (2026-04-02 15:36 UTC)
11
MIT
resume-mcp
Workplace & Productivity Project Management
ddavidgao
F
license
Not graded
quality
D
maintenance
MCP server for maintaining a professional profile database and generating tailored, ATS-optimized resumes for specific job postings.
Updated 5 months ago (2026-04-06 02:06 UTC)
1
mcp-server-cv-modify
RAG Systems AI & Machine Learning Web Scraping
ikrigel
F
license
A
quality
D
maintenance
MCP server that intelligently modifies CVs based on job descriptions using keyword extraction and strategic enhancement.
Updated 7 months ago (2026-01-28 15:10 UTC)
3
3
jobjourney-claude-plugin
Search Web Scraping Browser Automation
Rorogogogo
A
license
Not graded
quality
D
maintenance
An MCP server that enables AI-assisted job search workflows including job discovery, application tracking, resume evaluation, and cover letter generation, with support for multiple job sources and scheduled scraping.
Updated 3 months ago (2026-05-19 09:53 UTC)
18
1
AGPL 3.0

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/thechandanbhagat/cv-forge'

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

CV Forge

Features

Star History

Installation

Via npm (Recommended)

From Source

Usage

Connecting to Claude Desktop

Running the MCP Server Standalone (for testing)

Available Tools

1. parse_job_requirements

2. generate_cv_data

3. save_cv_text

4. generate_cv (Recommended - Main CV Generation Tool)

5. generate_and_save_cv_pdf (Legacy - Use generate_cv instead)

6. generate_and_save_cv_markdown (Recommended)

7. generate_and_save_cv_html (Recommended)

8. generate_cv_pdf (Advanced)

9. generate_cv_markdown (Advanced)

10. generate_cv_html (Advanced)

Cover Letter and Email Template Tools

11. generate_cover_letter (Recommended)

12. save_cover_letter_pdf

13. generate_email_template

14. draft_complete_application (Recommended - One-Stop Solution)

Configuration

Environment Variables

Example Usage with Claude Desktop

1. Parse Job Requirements

2. Generate Tailored CV (Simple One-Step Process - PDF by Default)

3. Generate Different Formats

3. Generate Cover Letters

4. Generate Email Templates

5. Draft Complete Application Package (Recommended)

6. Generate Follow-up Email Template

7. Direct Tool Usage Examples

How It Works

File Structure

Development

Building

Starting Development Server

Project Structure

Troubleshooting

PDF not saving to configured location

Font size too large or small

PDF generation fails

Custom page size not working

Custom margins not applied

Future Enhancements

Dependencies

License

Contributing

Available Tools

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

1. `parse_job_requirements`

2. `generate_cv_data`

3. `save_cv_text`

4. `generate_cv` (Recommended - Main CV Generation Tool)

5. `generate_and_save_cv_pdf` (Legacy - Use generate_cv instead)

6. `generate_and_save_cv_markdown` (Recommended)

7. `generate_and_save_cv_html` (Recommended)

8. `generate_cv_pdf` (Advanced)

9. `generate_cv_markdown` (Advanced)

10. `generate_cv_html` (Advanced)

11. `generate_cover_letter` (Recommended)

12. `save_cover_letter_pdf`

13. `generate_email_template`

14. `draft_complete_application` (Recommended - One-Stop Solution)