• Overview
• Features
• Demo
• Tech Stack
• Architecture
• Installation
• Configuration
• Usage
• API Documentation
• Project Structure
• Development
• Testing
• Deployment
• Contributing
• License
• Acknowledgments
• Contact

AI Resume & Job Description Matcher is a sophisticated tool that leverages natural language processing (NLP) and large language models (LLMs) to analyze how well a resume aligns with a job description. It provides actionable insights including similarity scores, skill gap analysis, and personalized recommendations to help candidates optimize their job applications.

• Save Time: Quickly identify which jobs match your skillset
• Get Insights: Understand exactly what skills you're missing
• Improve Applications: Tailor your resume to specific job requirements
• Data-Driven: Make informed decisions backed by AI analysis

• 📄 Multi-Format Resume Support: Upload resumes in PDF, DOCX, or TXT formats
• 📝 Job Description Analysis: Paste any job description for instant analysis
• 🤖 Dual Analysis Modes:
  • Traditional NLP: Rule-based skill extraction with sentence transformers
  • LLM-Powered: Advanced AI analysis using Llama 3.3 for accurate skill identification
• 📊 Semantic Similarity Scoring: Cosine similarity calculation using state-of-the-art embeddings
• 🎯 Skill Gap Analysis:
  • Categorized skills (Technical, Tools, Soft Skills)
  • Missing skills identification
  • Ranked missing skills by importance
• 📈 Visual Analytics: Interactive charts and metrics for skill overlap
• 🔄 Real-time Processing: Instant feedback as you upload and analyze

• Smart Skill Categorization: Automatically groups skills into meaningful categories
• Frequency Analysis: Ranks missing skills based on how often they appear in the JD
• Overlap Metrics: Detailed statistics on skill matching between resume and JD
• Clean UI/UX: Intuitive Streamlit interface with expandable sections
• API-First Design: RESTful API for easy integration with other tools

Upload your resume and paste a job description to see instant analysis

Semantic Match Score: 78.5%

Skill Overlap:
├── Resume Skills: 24
├── JD Skills: 18
└── Matched: 15

Top Missing Skills:
1. Docker (3 mentions)
2. Kubernetes (2 mentions)
3. AWS (2 mentions)

• FastAPI - Modern, fast web framework for building APIs
• Uvicorn - Lightning-fast ASGI server
• Python 3.8+ - Core programming language

• Streamlit - Interactive web application framework

• Sentence Transformers - State-of-the-art text embeddings (all-MiniLM-L6-v2)
• spaCy - Industrial-strength NLP library
• OpenAI API (via OpenRouter) - LLM integration for advanced skill extraction

• PyPDF2 - PDF text extraction
• python-docx - DOCX document parsing
• pdfminer.six - Advanced PDF text extraction

• Docker - Containerization (via devcontainer)
• GitHub Actions - CI/CD pipeline

┌─────────────────┐
│   Streamlit UI  │
│   (Frontend)    │
└────────┬────────┘
         │ HTTP Requests
         ↓
┌─────────────────┐
│   FastAPI       │
│   (Backend)     │
├─────────────────┤
│ ├─ utils.py     │ ← Document parsing
│ ├─ nlp_utils.py │ ← Embeddings & similarity
│ ├─ skills.py    │ ← Skill extraction
│ └─ llm_utils.py │ ← LLM integration
└────────┬────────┘
         │
         ↓
┌─────────────────────────────┐
│  External Services          │
├─────────────────────────────┤
│ • HuggingFace Models        │
│ • OpenRouter API (LLM)      │
└─────────────────────────────┘

• Python 3.8 or higher
• pip (Python package manager)
• Git
• OpenRouter API key (for LLM features)

1. Clone the repository

git clone https://github.com/Achal13jain/AI_resume_matcher.git
cd AI_resume_matcher

2. Create a virtual environment

# Linux/macOS
python3 -m venv venv
source venv/bin/activate

# Windows
python -m venv venv
.\venv\Scripts\activate

3. Install dependencies

pip install -r requirements.txt

4. Download spaCy language model

python -m spacy download en_core_web_sm

5. Set up environment variables

Create a .env file in the root directory:

OPENROUTER_API_KEY=your_openrouter_api_key_here

To get an OpenRouter API key, visit: https://openrouter.ai/

The application uses the following models by default:

• Embeddings: all-MiniLM-L6-v2 (Sentence Transformers)
• LLM: meta-llama/llama-3.3-70b-instruct:free (via OpenRouter)
• NLP: en_core_web_sm (spaCy)

These can be modified in the respective utility files (nlp_utils.py, llm_utils.py).

You need to run both the backend and frontend servers.

uvicorn backend.main:app --reload

The backend will be available at: http://127.0.0.1:8000

API documentation (Swagger UI): http://127.0.0.1:8000/docs

In a new terminal window:

streamlit run frontend/app.py

The UI will open automatically in your browser at: http://localhost:8501

1. Navigate to Resume Parser: Use the sidebar to go to the "📄 Resume Parser" page

2. Upload Resume: Click "Upload resume" and select your PDF, DOCX, or TXT file

3. Paste Job Description: Copy and paste the job description in the text area

4. Extract Skills: Click "Extract JD & Skills" to see categorized skills from both documents

5. Run Analysis:

   • Click "Match Now" for traditional NLP-based analysis
   • Click "Run LLM-based Match" for AI-powered analysis

6. Review Results: Examine the similarity score, skill gaps, and recommendations

curl -X POST "http://127.0.0.1:8000/upload_resume" \
  -F "file=@/path/to/resume.pdf"

curl -X POST "http://127.0.0.1:8000/match" \
  -F "resume_text=Your resume text here" \
  -F "jd_text=Job description text here"

Health check endpoint.

Response:

{
  "status": "ok"
}

Upload and parse a resume file.

Parameters:

• file (UploadFile): Resume file (PDF/DOCX/TXT)

Response:

{
  "filename": "resume.pdf",
  "text_snippet": "First 500 characters...",
  "full_text": "Complete extracted text"
}

Submit and clean job description text.

Parameters:

• jd_text (Form): Raw job description text

Response:

{
  "jd_snippet": "First 500 characters...",
  "full_text": "Complete cleaned text"
}

Extract categorized skills from text.

Request Body:

{
  "text": "Your text here"
}

Response:

{
  "technical": ["python", "sql", "machine learning"],
  "tools": ["git", "docker", "aws"],
  "soft_skills": ["communication", "teamwork"],
  "other_phrases": ["data analysis", "project management"]
}

Perform comprehensive matching analysis.

Parameters:

• resume_text (Form): Resume text
• jd_text (Form): Job description text

Response:

{
  "match_score": 78.5,
  "missing_skills": ["docker", "kubernetes"],
  "ranked_missing_skills": [
    {"skill": "docker", "count_in_jd": 3},
    {"skill": "kubernetes", "count_in_jd": 2}
  ],
  "resume_skills": {...},
  "jd_skills": {...},
  "overlap_count": 15,
  "resume_skill_count": 24,
  "jd_skill_count": 18
}

LLM-powered skill extraction and matching.

Parameters:

• resume_text (Form): Resume text
• jd_text (Form): Job description text

Response:

{
  "resume_skills": ["Python", "FastAPI", "SQL"],
  "jd_skills": ["Python", "Docker", "AWS"],
  "matched_skills": ["Python"],
  "missing_skills": ["Docker", "AWS"],
  "overlap_count": 1,
  "resume_skill_count": 3,
  "jd_skill_count": 3
}

AI_resume_matcher/
├── .devcontainer/
│   └── devcontainer.json       # VS Code devcontainer configuration
├── .github/
│   └── workflows/
│       └── ci.yml              # GitHub Actions CI pipeline
├── backend/
│   ├── __init__.py
│   ├── main.py                 # FastAPI application & routes
│   ├── utils.py                # Document parsing utilities
│   ├── nlp_utils.py            # NLP & embeddings logic
│   ├── skills.py               # Skill extraction & categorization
│   └── llm_utils.py            # LLM integration
├── frontend/
│   └── app.py                  # Streamlit web interface
├── .gitignore                  # Git ignore rules
├── README.md                   # Project documentation
└── requirements.txt            # Python dependencies

This project includes a devcontainer configuration for a consistent development environment.

1. Install Docker Desktop
2. Install VS Code and the "Dev Containers" extension
3. Open the project in VS Code
4. Click "Reopen in Container" when prompted

Follow the Installation instructions above.

This project follows PEP 8 guidelines. Please ensure your code is formatted before submitting PRs.

# Install development tools
pip install black flake8 pylint

# Format code
black backend/ frontend/

# Lint code
flake8 backend/ frontend/

To add new skills to the detection system, edit backend/skills.py:

TECHNICAL = [
    # Add your technical skills here
    "your_new_skill",
]

TOOLS = [
    # Add your tools here
    "your_new_tool",
]

# Install test dependencies
pip install pytest pytest-cov

# Run tests
pytest

# Run with coverage
pytest --cov=backend --cov-report=html

1. Start both servers (backend and frontend)
2. Upload a sample resume
3. Paste a sample job description
4. Verify all features work as expected

# Build Docker image
docker build -t ai-resume-matcher .

# Run container
docker run -p 8000:8000 -p 8501:8501 ai-resume-matcher

heroku create your-app-name
git push heroku main

Refer to the respective platform documentation for deploying FastAPI and Streamlit applications.

Contributions are welcome! Please follow these steps:

1. Fork the repository

2. Create a feature branch

   git checkout -b feature/AmazingFeature

3. Commit your changes

   git commit -m 'Add some AmazingFeature'

4. Push to the branch

   git push origin feature/AmazingFeature

5. Open a Pull Request

• Follow PEP 8 style guidelines
• Add tests for new features
• Update documentation as needed
• Ensure all tests pass before submitting PR

This project is licensed under the MIT License - see the LICENSE file for details.

• HuggingFace for the sentence-transformers library
• OpenRouter for LLM API access
• spaCy for NLP capabilities
• FastAPI for the excellent web framework
• Streamlit for the intuitive UI framework

Achal Jain - @Achal13jain

Project Link: https://github.com/Achal13jain/AI_resume_matcher

• Add support for more resume formats (RTF, HTML)
• Implement resume optimization suggestions
• Add cover letter generation feature
• Create browser extension
• Add support for multiple languages
• Implement user accounts and history tracking
• Add ATS (Applicant Tracking System) optimization tips
• Create mobile application