🎯 AI Resume Analyzer

Complete ATS-Powered Resume Analysis System

Parse resumes • Extract skills • Match keywords • Calculate ATS scores • Generate AI feedback

📋 Table of Contents

✨ Introduction
⚙️ Tech Stack
🔋 Features
🏗️ System Architecture
🤸 Quick Start
📡 API Documentation
💻 Usage Examples
🎨 UI Components
🔧 Configuration
📊 Performance
🚀 Deployment
🤝 Contributing

✨ Introduction

AI Resume Analyzer is a comprehensive, production-ready system that analyzes resumes against job descriptions using advanced ATS (Applicant Tracking System) algorithms and optional LLM integration. Built with modern web technologies, it provides instant, actionable feedback to help job seekers optimize their resumes.

What Makes This Special?

🚀 Complete Pipeline: Upload → Parse → Match → Score → Feedback (all in one call)
🤖 LLM Integration: OpenAI GPT-4, Google Gemini, or Anthropic Claude for semantic analysis
⚡ Lightning Fast: <250ms processing without LLM, ~2-5s with LLM
🎯 Smart Matching: 150+ predefined skills with intelligent keyword matching
📊 Detailed Scoring: ATS score (0-100) with comprehensive breakdown
💡 Actionable Feedback: Categorized suggestions (Critical/Important/Suggestion)
🎨 Beautiful UI: Modern, responsive design with dark mode support
🔒 Privacy-First: Memory-only processing, no data persistence

⚙️ Tech Stack

React is a popular open‑source JavaScript library for building user interfaces using reusable components and a virtual DOM, enabling efficient, dynamic single-page and native apps.
React Router v7 is the go‑to routing library for React apps, offering nested routes, data loaders/actions, error boundaries, code splitting, and SSR support—all with a smooth upgrade path from v6.
Puter.com is an advanced, open-source internet operating system designed to be feature-rich, exceptionally fast, and highly extensible. Puter can be used as: A privacy-first personal cloud to keep all your files, apps, and games in one secure place, accessible from anywhere at any time.
Puter.js is a tiny client‑side SDK that adds serverless auth, storage, database, and AI (GPT, Claude, DALL·E, OCR…) straight into your browser app—no backend needed and costs borne by users.
Tailwind CSS is a utility-first CSS framework that allows developers to design custom user interfaces by applying low-level utility classes directly in HTML, streamlining the design process.
TypeScript is a superset of JavaScript that adds static typing, providing better tooling, code quality, and error detection for developers, making it ideal for building large-scale applications.
Vite is a fast build tool and dev server using native ES modules for instant startup, hot‑module replacement, and Rollup‑powered production builds—perfect for modern web development.
Zustand is a minimal, hook-based state management library for React. It lets you manage global state with zero boilerplate, no context providers, and excellent performance through selective state subscriptions.

🔋 Features

📄 Resume Parsing

✅ PDF & DOCX Support - Parse both PDF and DOCX resume files
✅ Text Extraction - Extract full plain text from documents
✅ Field Detection - Automatically detect name, email, phone, skills, education, work experience
✅ Metadata Analysis - Calculate word count, text statistics

🎯 Skill Extraction & Matching

✅ 150+ Predefined Skills - Technical (programming, frameworks, databases, cloud) and soft skills
✅ Smart Matching - Exact and partial keyword matching with word boundary detection
✅ N-gram Extraction - Capture multi-word skills (e.g., "Machine Learning", "React Native")
✅ Text Preprocessing - Lowercase, tokenization, stopword removal
✅ Match Analysis - Identify matched vs missing keywords with percentage calculation

📊 ATS Scoring Algorithm

✅ 0-100 Score - Formula-based scoring: (Matched/Total) × 100
✅ Format Penalty - Deduct points for poor formatting (0-20 points)
✅ Section Completeness - Bonus points for standard sections (0-10 points)
✅ Detailed Breakdown - Matched keywords, missing keywords, total keywords
✅ Pass/Fail Determination - Configurable threshold (default: 70%)

🤖 LLM Integration

✅ Multi-Provider Support - OpenAI GPT-4, Google Gemini, Anthropic Claude
✅ Context-Rich Prompts - Send resume, JD, keywords, ATS score for analysis
✅ Structured Feedback - Summary, suggestions, keyword improvements, formatting tips
✅ Smart Fallback - Works perfectly without LLM using static feedback
✅ Error Handling - Graceful degradation on API failures or timeouts

📡 API Endpoints

✅ /api/parse-resume - Parse PDF/DOCX files
✅ /api/ats-score - Calculate ATS score and feedback
✅ /api/generate-feedback - Generate LLM-powered feedback
✅ /api/full-analysis - Complete end-to-end pipeline in one call

🎨 UI/UX

✅ Modern Design - Clean, responsive interface built with Tailwind CSS
✅ Dark Mode - Full theme support
✅ Interactive Elements - Color-coded feedback, keyword badges, expandable sections
✅ Real-time Results - Instant feedback display
✅ Loading States - Smooth transitions and loading indicators
✅ Error Handling - User-friendly error messages

🔧 Developer Experience

✅ TypeScript - Full type safety across the entire codebase
✅ Modular Architecture - Clean separation of concerns
✅ React Hooks - Easy-to-use hooks for API consumption
✅ Comprehensive Documentation - Detailed guides and examples
✅ Test Pages - Built-in demo pages for testing (/test-parser, /test-ats)

🤸 Quick Start

Follow these steps to set up the project locally on your machine.

Prerequisites

Make sure you have the following installed on your machine:

Git
Node.js
npm (Node Package Manager)

Cloning the Repository

git clone https://github.com/your-username/ai-resume-analyzer.git
cd ai-resume-analyzer

Installation

Install the project dependencies:

npm install

Install additional dependencies for resume parsing:

npm install pdf-parse mammoth @types/pdf-parse

Environment Variables (Optional - for LLM Integration)

Create a .env file in the root directory:

# LLM Configuration (optional - system works without it)
LLM_PROVIDER=openai          # Options: openai, gemini, anthropic
LLM_API_KEY=your_api_key_here
LLM_MODEL=gpt-4-turbo-preview
LLM_MAX_TOKENS=1500
LLM_TEMPERATURE=0.7

Running the Project

npm run dev

Open http://localhost:5173 in your browser to view the project.

Test Pages

Resume Parser: http://localhost:5173/test-parser
ATS Scorer: http://localhost:5173/test-ats

🏗️ System Architecture

┌─────────────────────────────────────────────────────────────┐
│                     Frontend (React)                         │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │ Upload Page  │  │ Test Parser  │  │  Test ATS    │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
└─────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                    API Layer (React Router)                  │
│  ┌──────────────────┐  ┌──────────────────┐                │
│  │ /api/parse-resume│  │ /api/ats-score   │                │
│  └──────────────────┘  └──────────────────┘                │
│  ┌──────────────────┐  ┌──────────────────┐                │
│  │ /api/generate-   │  │ /api/full-       │                │
│  │     feedback     │  │    analysis      │                │
│  └──────────────────┘  └──────────────────┘                │
└─────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                   Core Libraries (app/lib)                   │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │file-parsers  │  │skill-extractor│  │skill-matcher │      │
│  │(PDF/DOCX)    │  │(150+ skills)  │  │(matching)    │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │ats-scorer    │  │llm-service   │  │resume-parser │      │
│  │(algorithm)   │  │(OpenAI/etc)  │  │(fields)      │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
└─────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│              External Services (Optional)                    │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │  OpenAI GPT  │  │Google Gemini │  │Anthropic     │      │
│  │     API      │  │     API      │  │Claude API    │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
└─────────────────────────────────────────────────────────────┘

Processing Pipeline

1. Upload Resume (PDF/DOCX)
   ↓
2. Parse File → Extract Text
   ↓
3. Extract Skills & Keywords
   ↓
4. Match with Job Description
   ↓
5. Calculate ATS Score
   ↓
6. Generate Feedback (LLM or Static)
   ↓
7. Display Results

📡 API Documentation

1. Parse Resume

Endpoint: POST /api/parse-resume

Content-Type: multipart/form-data

Request:

const formData = new FormData();
formData.append('resume', file); // PDF or DOCX file

Response:

{
  "status": "success",
  "text": "Full resume text...",
  "fields": {
    "name": "John Doe",
    "email": "john@example.com",
    "phone": "+1234567890",
    "skills": ["Python", "React", "AWS"],
    "education": [...],
    "workExperience": [...]
  },
  "fileType": "pdf",
  "stats": {
    "textLength": 2500,
    "wordCount": 450
  }
}

2. Calculate ATS Score

Endpoint: POST /api/ats-score

Content-Type: application/json

Request:

{
  "resumeText": "Full resume text...",
  "jobDescription": "Job description text...",
  "resumeSkills": ["Python", "React"],
  "passThreshold": 70
}

Response:

{
  "atsScore": 75,
  "atsPass": true,
  "passThreshold": 70,
  "scoreBreakdown": {
    "matchedKeywords": 8,
    "missingKeywords": 3,
    "totalKeywords": 11,
    "formatPenalty": 5,
    "sectionCompleteness": 8
  },
  "feedback": [
    {
      "category": "important",
      "message": "Missing 3 important keywords.",
      "action": "Consider adding: AWS, Docker, Kubernetes."
    }
  ],
  "skillMatch": {
    "matchedKeywords": ["Python", "React", "Node.js"],
    "missingKeywords": ["AWS", "Docker", "Kubernetes"],
    "matchPercentage": 73
  },
  "recommendations": [...]
}

3. Generate LLM Feedback

Endpoint: POST /api/generate-feedback

Content-Type: application/json

Request:

{
  "resumeText": "...",
  "jobDescription": "...",
  "matchedKeywords": ["Python", "React"],
  "missingKeywords": ["AWS", "Docker"],
  "atsScore": 75
}

Response:

{
  "feedback": {
    "summary": "Your resume demonstrates strong technical skills...",
    "suggestions": ["Add AWS certification...", "..."],
    "keywordImprovements": ["Include Docker in DevOps section..."],
    "formattingTips": ["Use consistent bullet points..."],
    "sectionEnhancements": ["Expand Skills section..."],
    "overallRecommendation": "With these improvements...",
    "estimatedImpact": "medium"
  },
  "provider": "openai",
  "model": "gpt-4-turbo-preview",
  "status": "success"
}

4. Full Analysis Pipeline ⭐

Endpoint: POST /api/full-analysis

Content-Type: multipart/form-data

Request:

const formData = new FormData();
formData.append('resume', file);
formData.append('jobDescription', 'Job description text...');
formData.append('jobTitle', 'Software Engineer');
formData.append('useLLM', 'true'); // optional

Response: Combined results from all steps above

💻 Usage Examples

Using React Hooks

import { useResumeParser } from '~/lib/use-resume-parser';
import { useATSScorer } from '~/lib/use-ats-scorer';

function MyComponent() {
  const parser = useResumeParser();
  const scorer = useATSScorer();

  const handleAnalyze = async (file: File, jobDesc: string) => {
    // Step 1: Parse resume
    const parsed = await parser.parseResume(file);
    
    if (parsed) {
      // Step 2: Calculate ATS score
      const score = await scorer.calculateScore({
        resumeText: parsed.text,
        resumeSkills: parsed.fields.skills,
        jobDescription: jobDesc,
      });
      
      console.log('ATS Score:', score?.atsScore);
      console.log('Matched:', score?.skillMatch.matchedKeywords);
      console.log('Missing:', score?.skillMatch.missingKeywords);
    }
  };

  return (
    <div>
      {/* Your UI */}
    </div>
  );
}

Using Full Analysis API

async function analyzeResume(file: File, jobDescription: string) {
  const formData = new FormData();
  formData.append('resume', file);
  formData.append('jobDescription', jobDescription);
  formData.append('useLLM', 'true');

  const response = await fetch('/api/full-analysis', {
    method: 'POST',
    body: formData,
  });

  const result = await response.json();
  
  console.log('ATS Score:', result.atsScoring.atsScore);
  console.log('Matched Keywords:', result.skillMatching.matchedKeywords);
  console.log('LLM Feedback:', result.llmFeedback?.feedback);
  
  return result;
}

cURL Examples

Parse Resume:

curl -X POST http://localhost:5173/api/parse-resume \
  -F "resume=@resume.pdf"

Calculate ATS Score:

curl -X POST http://localhost:5173/api/ats-score \
  -H "Content-Type: application/json" \
  -d '{
    "resumeText": "Software Engineer with Python, React...",
    "jobDescription": "Looking for Python, React, AWS..."
  }'

Full Analysis:

curl -X POST http://localhost:5173/api/full-analysis \
  -F "resume=@resume.pdf" \
  -F "jobDescription=Looking for Python, React, AWS..." \
  -F "useLLM=true"

🎨 UI Components

ResumeParserDemo

Located at /test-parser, this component demonstrates resume parsing:

File upload interface
Parsing progress indicator
Extracted fields display
Skills as badges
Full text viewer
Error handling

ATSScorerDemo

Located at /test-ats, this component demonstrates ATS scoring:

Side-by-side text input (resume + job description)
Real-time scoring
Color-coded results (green/yellow/red based on score)
Keyword badges (matched in green, missing in red)
Expandable feedback sections
Recommendations list
Score breakdown visualization

🔧 Configuration

LLM Providers

OpenAI:

LLM_PROVIDER=openai
LLM_API_KEY=sk-...
LLM_MODEL=gpt-4-turbo-preview

Google Gemini:

LLM_PROVIDER=gemini
LLM_API_KEY=...
LLM_MODEL=gemini-pro

Anthropic Claude:

LLM_PROVIDER=anthropic
LLM_API_KEY=...
LLM_MODEL=claude-3-sonnet-20240229

Custom Skills

Add industry-specific skills:

import { SkillExtractor } from '~/lib/skill-extractor';

const customSkills = ['Rust', 'Elixir', 'Blockchain', 'Web3'];
const extractor = new SkillExtractor(customSkills);

ATS Threshold

Adjust the pass/fail threshold:

import { ATSScorer } from '~/lib/ats-scorer';

const scorer = new ATSScorer(80); // 80% threshold instead of default 70%

📊 Performance

Operation	Time	Notes
PDF Parsing	~100ms	Typical 2-page resume
DOCX Parsing	~50ms	Faster than PDF
Skill Extraction	~50ms	150+ skills checked
Keyword Matching	~20ms	Smart comparison
ATS Scoring	~10ms	Formula-based
Total (without LLM)	~230ms	Very fast
LLM Feedback	2-5s	Depends on provider
Total (with LLM)	~2.5-5.5s	Still acceptable

Optimization Tips

Cache parsed resumes to avoid re-parsing
Batch process multiple resumes
Use LLM only when needed (fallback is fast)
Monitor API usage for LLM costs

🚀 Deployment

Deployment Checklist

Environment Variables for Production

NODE_ENV=production
LLM_PROVIDER=openai
LLM_API_KEY=your_production_key
LLM_MODEL=gpt-4-turbo-preview
LLM_MAX_TOKENS=1500
LLM_TEMPERATURE=0.7

🤝 Contributing

Contributions are welcome! Please follow these steps:

Fork the repository
Create a feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'Add some AmazingFeature')
Push to the branch (git push origin feature/AmazingFeature)
Open a Pull Request

Development Guidelines

Follow TypeScript best practices
Add tests for new features
Update documentation
Ensure all tests pass
Follow existing code style

📄 License

This project is licensed under the MIT License.

🙏 Acknowledgments

pdf-parse - PDF parsing library
mammoth - DOCX parsing library
OpenAI, Google, Anthropic - LLM providers
React Router - Routing framework
Tailwind CSS - Styling framework

📞 Support

For questions or issues:

Open an issue on GitHub
Check the test pages: /test-parser, /test-ats
Review API documentation: GET any endpoint for docs

Built with ❤️ for job seekers everywhere

⭐ Star this repo if you find it helpful!

Name		Name	Last commit message	Last commit date
Latest commit History 1 Commit
app		app
constants		constants
public		public
types		types
Dockerfile		Dockerfile
README.md		README.md
package-lock.json		package-lock.json
package.json		package.json
react-router.config.ts		react-router.config.ts
tsconfig.json		tsconfig.json
vite.config.ts		vite.config.ts

Folders and files

Latest commit

History

Repository files navigation

🎯 AI Resume Analyzer

📋 Table of Contents

What Makes This Special?

📄 Resume Parsing

🎯 Skill Extraction & Matching

📊 ATS Scoring Algorithm

🤖 LLM Integration

📡 API Endpoints

🎨 UI/UX

🔧 Developer Experience

Processing Pipeline

1. Parse Resume

2. Calculate ATS Score

3. Generate LLM Feedback

4. Full Analysis Pipeline ⭐

Using React Hooks

Using Full Analysis API

cURL Examples

ResumeParserDemo

ATSScorerDemo

LLM Providers

Custom Skills

ATS Threshold

Optimization Tips

Deployment Checklist

Environment Variables for Production

Development Guidelines

📄 License

🙏 Acknowledgments

📞 Support

About

Resources

Uh oh!

Stars

Watchers

Forks

Uh oh!

Uh oh!

Languages