Open Source Tools for AI-Powered Resume Screening

Tested prompts for open source ai resume screening compared across 5 leading AI models.

BEST BY JUDGE SCORE Claude Opus 4.7 6/10

If you searched for open source AI resume screening, you're probably a recruiter, HR tech builder, or startup trying to automate candidate filtering without paying for expensive ATS add-ons or locked SaaS tools. You want something you can inspect, modify, and run on your own infrastructure. That's a legitimate and increasingly common need as hiring volume grows and privacy concerns around third-party resume parsing intensify.

The core problem is straightforward: you have a job description and a pile of resumes, and you need a consistent, explainable filter that surfaces the best-fit candidates before a human spends time reading. Open source LLMs and prompt-based pipelines now make this possible without vendor lock-in. You can run models like Mistral, LLaMA 3, or Qwen locally or on a cheap cloud VM, feed them structured prompts, and get scored, ranked outputs.

This page shows exactly how to build that prompt, compares outputs across four leading models, and gives you the context to decide whether this approach fits your situation. The comparison table further down handles the model-by-model breakdown. What follows is the editorial layer: what this is good for, where it fails, and how to do it right.

When to use this

Open source AI resume screening is the right fit when you control your own pipeline, handle sensitive candidate data that can't leave your servers, or need to customize scoring criteria beyond what off-the-shelf ATS tools allow. It also suits teams running high-volume hiring sprints where manual review of every resume is not feasible.

A startup doing a 200+ applicant hiring push who can't justify a $500/month ATS premium tier
An HR tech team building a white-label recruiting tool and needing full control over the scoring logic
A company with GDPR or HIPAA constraints that prohibits sending candidate data to third-party APIs
A technical recruiter who wants to weight niche skills (e.g., Rust, CUDA, specific compliance frameworks) that generic tools miss
An engineering team prototyping an internal HR automation tool on top of a self-hosted LLM like Ollama

When this format breaks down

You have fewer than 20 applicants per role: manual review is faster and more accurate than setting up a prompt pipeline.
Your team has no technical capacity to run or maintain a local model or API integration: the setup overhead will outweigh the benefit.
You are operating in a jurisdiction with strict AI-in-hiring laws (e.g., New York City Local Law 144) and have no audit or bias-testing infrastructure: deploying unvalidated AI screening exposes you to legal risk.
The role requires deep contextual judgment, such as executive or creative hires, where resume keywords are a poor proxy for fit and LLM scoring will produce misleading confidence.

The prompt we tested

You are an expert in open source HR tech and AI-powered recruitment tools. Your task is to recommend open source AI resume screening projects that match the user's needs.

Return 4-6 open source projects in a markdown table with columns: Project Name, GitHub/Link, Key Features, Tech Stack, License. Follow the table with a brief 'Recommendation' paragraph (3-4 sentences) tailored to the user's use case. Only include genuinely open source projects (MIT, Apache 2.0, GPL, etc.)—no proprietary or freemium SaaS tools.

User's situation and requirements:
We're a 50-person startup hiring for engineering roles and receive about 200 resumes per job posting. We want a self-hosted open source tool that can parse PDFs, rank candidates against a job description using LLMs, and integrate with our existing Python-based ATS. Budget is limited so ideally something we can run on our own infrastructure.

Provide a curated list of open source AI resume screening tools and projects, including GitHub links where possible, key features, tech stack (e.g., NLP libraries, LLMs used), licensing, setup complexity, and which option best fits the user's stated needs. End with a short recommendation of the top 1-2 picks and why.

Model comparison

Model	Quality	Cost	Latency	Tokens
Claude Opus 4.7	6	$0.0997	20.7s	422 / 1245
Claude Haiku 4.5	3	$0.0041	7.4s	293 / 766
GPT-5.4	6	$0.0121	15.4s	265 / 765
Grok 4.1 Fast Reasoning	5	$0.0004	42.0s	411 / 673

Outputs

Claude Opus 4.7 6/10

# Open Source AI Resume Screening Tools

| Project Name | GitHub/Link | Key Features | Tech Stack | License |
|---|---|---|---|---|
| **Resume-Matcher** | [github.com/srbhr/Resume-Matcher](https://github.com/srbhr/Resume-Matcher) | PDF parsing, keyword matching, cosine similarity scoring against JD, vector-based ranking, Next.js UI | Python, FastAPI, Qdrant, Ollama (local LLMs), spaCy | Apache 2.0 |
| **OpenResume-Screener (AI-Resume-Analyzer)** | [github.com/tbhaxor/ai-resume-analyzer](https://github.com/tbhaxor/ai-resume-analyzer) | Resume parsing, JD matching, LLM-based scoring, explainable ranking | Python, LangChain, OpenAI/Ollama, Streamlit | MIT |
| **JobFair (Resume Ranking)** | [github.com/alfredfrancis/job-fair](https://github.com/alfredfrancis/job-fair) | Resume parsing, bulk ranking, REST API for ATS integration, embedding-based similarity | Python, Flask, Sentence-Transformers, PyPDF2 | MIT |
| **OpenResume** | [github.com/xitanggg/open-resume](https://github.com/xitanggg/open-resume) | Robust PDF resume parser (can be used as a parsing component) | TypeScript, React, pdf.js | AGPL-3.0 |
| **Hirebot / Smart-Resume-Analyser** | [github.com/deepakpadhi986/AI-Resume-Analyzer](https://github.com/deepakpadhi986/AI-Resume-Analyzer) | Parses resumes, extracts skills/experience, scoring dashboard, MySQL storage | Python, NLTK, pyresparser, Streamlit | MIT |
| **Resume-Parser (HR-Analytics)** | [github.com/OmkarPathak/pyresparser](https://github.com/OmkarPathak/pyresparser) | Reliable PDF/DOCX parser, extracts structured fields (skills, education, experience) | Python, spaCy, NLTK, pdfminer | GPL-3.0 |
| **Haystack + custom pipeline** | [github.com/deepset-ai/haystack](https://github.com/deepset-ai/haystack) | Build custom RAG pipeline: embed JD + resumes, rank with LLM, fully self-hosted | Python, Transformers, FAISS/Elasticsearch, Ollama/Llama.cpp | Apache 2.0 |

## Recommendation

For your stack, **Resume-Matcher** is the strongest turnkey pick: it's Python-native, actively maintained, supports local LLMs via Ollama (Llama 3, Mistral) so you avoid API costs, parses PDFs out of the box, and exposes a FastAPI layer that your existing Python ATS can call directly. For 200 resumes per posting it will run comfortably on a modest GPU box or even CPU with smaller embedding models.

If you need more control over ranking logic and explainability, I'd pair **pyresparser** (for structured PDF extraction) with a custom **Haystack** pipeline using sentence-transformer embeddings plus a local LLM for final re-ranking against the job description. This combo is slightly more setup work but gives you a production-grade, fully self-hosted system that integrates cleanly as a microservice in your ATS—ideal for a budget-conscious 50-person startup that wants to scale its screening without vendor lock-in.

Claude Haiku 4.5 3/10

# Open Source AI Resume Screening Projects

| Project Name | GitHub/Link | Key Features | Tech Stack | License |
|---|---|---|---|---|
| **Talentlyft** | [github.com/talentlyft/talentlyft](https://github.com/talentlyft/talentlyft) | Resume parsing, candidate ranking, job matching, REST API | Python, FastAPI, LangChain, PostgreSQL, OpenAI/Ollama | MIT |
| **ResumeScreener** | [github.com/qdrant/resume-screener](https://github.com/qdrant/resume-screener) | Vector-based resume matching, semantic search, PDF parsing, bulk screening | Python, Qdrant (vector DB), LangChain, FastAPI, Hugging Face | Apache 2.0 |
| **Haystack Resume Parser** | [github.com/deepset-ai/haystack](https://github.com/deepset-ai/haystack) | Modular NLP pipeline, document parsing, LLM-agnostic ranking, custom workflows | Python, Haystack, LangChain, Transformers, Elasticsearch | Apache 2.0 |
| **Resume Matcher** | [github.com/srbhr/resume-matcher](https://github.com/srbhr/resume-matcher) | ATS-style matching, PDF/DOCX parsing, similarity scoring, simple web UI | Python, Flask, scikit-learn, FAISS, sentence-transformers | Apache 2.0 |
| **OpenRecruitment** | [github.com/openrecruit/openrecruit](https://github.com/openrecruit/openrecruit) | Full recruitment workflow, resume scoring, candidate pipeline, Docker ready | Python, Django, PostgreSQL, spaCy, scikit-learn | GPL 3.0 |
| **CVParser** | [github.com/deepset-ai/haystack-demos](https://github.com/deepset-ai/haystack-demos/tree/main/applications/cv_parser) | PDF extraction, structured CV data extraction, LLM-powered entity recognition | Python, Haystack, pydantic, PDF2Image, LLMs | Apache 2.0 |

---

## Recommendation

For your 50-person startup with 200 resumes per posting, **Resume Matcher** and **ResumeScreener** are the best fits. **Resume Matcher** is the quickest to deploy (lightweight, minimal dependencies) and uses vector embeddings (sentence-transformers) that work offline without LLM API costs—ideal for budget constraints and rapid screening of large batches. **ResumeScreener** is more sophisticated if you want semantic matching at scale, integrating Qdrant for production-grade vector search with optional LLM re-ranking for final candidates.

Both have straightforward Python APIs for integrating with your existing ATS, support PDF parsing out-of-the-box, and can run entirely on your infrastructure without vendor lock-in. Start with **Resume Matcher** for speed and simplicity, then graduate to **ResumeScreener** if you need finer ranking precision. Avoid GPL-licensed OpenRecruitment unless you plan to open-source your modifications—the Apache 2.0 options give you more flexibility for proprietary extensions.

GPT-5.4 6/10

Here’s a curated list of genuinely open source, self-hostable projects and building blocks that fit a startup hiring workflow for AI-assisted resume screening.

| Project Name | GitHub/Link | Key Features | Tech Stack | License |
|---|---|---|---|---|
| **Resume Matcher** | https://github.com/srbhr/Resume-Matcher | Open source resume-to-job-description matching; parses resumes; semantic similarity scoring; useful as a lightweight screening/ranking engine; can be adapted for batch ranking in hiring workflows. **Setup complexity:** Low–Medium. | Python, NLP/embeddings, PDF text extraction, Streamlit-style app components in many forks/implementations | **MIT** |
| **PyResparser** | https://github.com/OmkarPathak/pyresparser | Resume parsing library for extracting name, email, skills, education, experience from PDF/DOCX; good as a parsing layer inside a custom ATS pipeline. **Setup complexity:** Low. | Python, spaCy, NLTK, PDFMiner / text extraction libraries | **MIT** |
| **OpenResume** | https://github.com/xitanggg/open-resume | Primarily an open source resume parser/builder with strong PDF handling and structured resume data extraction; helpful for ingestion/normalization before scoring; self-hostable. **Setup complexity:** Medium. | TypeScript, Next.js/React, PDF parsing, structured document processing | **AGPL-3.0** |
| **Docparser-style OSS pipeline with Haystack** | https://github.com/deepset-ai/haystack | Not a resume screener out of the box, but an excellent open source framework to build LLM-powered candidate ranking: ingest PDFs, chunk/index resumes, compare against job descriptions, do retrieval + LLM scoring, expose Python APIs for ATS integration. **Setup complexity:** Medium–High. | Python, Haystack, Elasticsearch/OpenSearch/FAISS, Transformers, OpenAI-compatible or local LLMs | **Apache-2.0** |
| **Flowise** | https://github.com/FlowiseAI/Flowise | Visual open source LLM workflow builder that can orchestrate resume parsing, embedding, JD matching, and scoring pipelines; easy to self-host and connect to Python services via API/webhooks. **Setup complexity:** Medium. | Node.js, LangChain, vector DB integrations, local/OpenAI-compatible LLMs | **Apache-2.0** |
| **RAGFlow** | https://github.com/infiniflow/ragflow | Open source RAG platform for document ingestion and LLM-based ranking/extraction; can ingest resumes, support semantic search against JD criteria, and run self-hosted for screening workflows. **Setup complexity:** Medium–High. | Python, TypeScript, OCR/PDF ingestion, vector search, LLM integrations | **Apache-2.0** |

## Recommendation

For your use case, the **best fit is a combination of `PyResparser` + `Haystack`**: PyResparser handles structured extraction from PDFs, while Haystack gives you a robust, fully open source Python framework to rank candidates against job descriptions using local or API-based LLMs. This combination is self-hostable, budget-friendly, and integrates cleanly with a Python-based ATS.

If you want something faster to prototype with less engineering effort, **Resume Matcher** is a strong lightweight option for direct resume-to-JD scoring, though it is less production-ready than a custom Haystack pipeline. For a more no-code/low-code orchestration layer, **Flowise** is a good second pick, especially if your team wants to iterate on ranking logic visually before embedding it into your ATS.

Grok 4.1 Fast Reasoning 5/10

| Project Name | GitHub/Link | Key Features | Tech Stack | License | Setup Complexity |
|--------------|-------------|--------------|------------|---------|------------------|
| Resume-Matcher | [srbhr/Resume-Matcher](https://github.com/srbhr/Resume-Matcher) | PDF parsing, skill/education extraction, semantic similarity ranking against JD (0-100 score), Flask web UI, batch processing support | Python, PyMuPDF, sentence-transformers (local BERT-like models), NLTK, scikit-learn, Flask | MIT | Low (pip install dependencies, run Flask app; Docker support) |
| pyresparser | [OmkarPathak/pyresparser](https://github.com/OmkarPathak/pyresparser) | Parses PDFs/DOCs into structured JSON (skills, experience, education, contact info), NER-based extraction; easy to extend with LLMs for ranking | Python, spaCy (NLP), PyMuPDF, pdfplumber | MIT | Low (pip install, single command to parse) |
| DeepCV | [DeepLcom/deepcv](https://github.com/DeepLcom/deepcv) | Advanced PDF parsing to JSON, extracts 20+ fields (skills, job history, years of exp), ML-based classification/tagging, batch mode | Python, pdfminer.six, NLTK, scikit-learn | Apache 2.0 | Medium (pip install, some ML model downloads) |
| LLM-Job-Resume-Matcher | [0xZDH/LLM-Job-Resume-Matcher](https://github.com/0xZDH/LLM-Job-Resume-Matcher) | PDF parsing, LLM-powered ranking/scoring against JD, customizable prompts, batch screening for high volume | Python, Ollama (local LLMs like Llama3), pdfplumber, Pydantic | MIT | Medium (install Ollama, pull model, run script/app) |
| resuLLMe | [anshulbharath/resuLLMe](https://github.com/anshulbharath/resuLLMe) | RAG-based screening with local LLMs, PDF parsing, ranks/summarizes candidates vs JD, Python API for integration | Python, LlamaIndex, GPT4All/Ollama (local LLMs), PyMuPDF | MIT | Medium (pip install, setup local LLM backend) |

**Recommendation**  
For your 50-person startup handling ~200 engineering resumes per posting, Resume-Matcher stands out as the top pick due to its lightweight, fully local transformer-based ranking (no GPU/LLM server needed), seamless PDF parsing, and easy Python integration with your ATS—ideal for quick self-hosted deployment on limited infrastructure. If you need more nuanced LLM reasoning (e.g., for complex engineering skill matching), pair it with pyresparser for parsing or go with LLM-Job-Resume-Matcher as a close second, which runs efficiently on Ollama for batch processing without external APIs. Both options keep costs at zero beyond your servers and offer Python extensibility for ATS workflows.  

**Top Picks**: 1. Resume-Matcher (fastest setup, efficient for volume without LLMs); 2. LLM-Job-Resume-Matcher (best LLM fit for accurate JD ranking, still self-hosted).

What makes these work

01

Anchor the prompt to the job description
Paste the actual job requirements into the prompt rather than describing the role in general terms. LLMs score more accurately when they can compare resume text against explicit criteria. Generic prompts like 'is this person a good fit' produce vague outputs that require human re-interpretation anyway.
02

Request a structured output format
Ask the model to return a score, a short rationale, a list of matched criteria, and a list of gaps. This forces the model to reason through its answer rather than produce a single judgment. Structured output also makes downstream automation, like filtering by score threshold, much easier to build.
03

Set explicit scoring criteria weights
If Python is mandatory and Kubernetes is a nice-to-have, tell the model that in the prompt. Without weighting guidance, most models treat all listed skills as roughly equal, which inflates scores for candidates who hit many optional criteria while missing required ones.
04

Run the same resume through twice and compare
LLMs have some output variability even at low temperature settings. For high-stakes screening decisions, run the prompt twice and flag cases where scores diverge by more than 10 points for human review. This is a simple consistency check that costs almost nothing with local models.

More example scenarios

#01 · Software engineering role with hard skill requirements

Input

Job: Senior Backend Engineer. Requirements: 5+ years Python, experience with distributed systems, Kafka or RabbitMQ, PostgreSQL. Nice to have: Kubernetes, Go. Resume: 7 years Python, built event-driven architecture on RabbitMQ at fintech startup, PostgreSQL daily use, some Docker. No Kubernetes or Go mentioned.

Expected output

Match score: 82/100. Strong fit on core requirements: Python tenure exceeds threshold, RabbitMQ experience directly relevant, PostgreSQL confirmed. Gaps: no Kubernetes or Go. Recommend advancing to technical screen. Flag: distributed systems claim is implied but not explicitly detailed.

#02 · Healthcare compliance role with certification filters

Input

Job: Healthcare Compliance Analyst. Requirements: HIPAA expertise, 3+ years in healthcare operations, experience with audit preparation. Preferred: CHC certification. Resume: 4 years as compliance coordinator at regional hospital, led two HIPAA audits, no CHC listed, holds CHPC certification instead.

Expected output

Match score: 76/100. Meets years of experience and HIPAA audit requirements. CHPC is a recognized privacy credential and partially offsets absent CHC. Recommend human review to assess whether CHPC scope covers the role's audit preparation needs before advancing.

#03 · Entry-level marketing role with portfolio signals

Input

Job: Junior Content Marketer. Requirements: SEO writing experience, familiarity with CMS platforms, ability to manage editorial calendar. Resume: Recent grad, 6-month internship writing blog posts optimized for search, used WordPress and Webflow, helped coordinate weekly content calendar for 10-person team.

Expected output

Match score: 71/100. Internship experience maps directly to all three requirements at a junior scope. WordPress and Webflow confirm CMS exposure. Editorial calendar involvement is lightweight but present. Suitable for first-round interview given entry-level framing of the role.

#04 · Data science role with a career changer applicant

Input

Job: Data Scientist. Requirements: Python or R, machine learning model deployment experience, SQL. Resume: Former civil engineer, completed two-year MS in Data Science, capstone involved deploying a regression model via Flask API, strong SQL from graduate coursework, no industry ML experience.

Expected output

Match score: 58/100. Technical skills are present and verified through graduate work. Deployment experience is academic, not production. SQL is confirmed. The lack of industry ML experience is a meaningful gap for this role. Recommend only if pipeline is thin or role is explicitly junior-track.

#05 · Remote customer success role with SaaS context

Input

Job: Customer Success Manager, B2B SaaS. Requirements: 2+ years in customer success or account management, experience with Salesforce or HubSpot, track record of reducing churn. Resume: 3 years CSM at project management SaaS, used Salesforce daily, QBRs with enterprise accounts, helped reduce churn by 18% over two quarters.

Expected output

Match score: 91/100. Strong match across all criteria. SaaS context is directly transferable. Salesforce confirmed. Quantified churn reduction is exactly the signal the job posting calls for. Prioritize for recruiter screen.

Common mistakes to avoid

Using raw resume PDFs without parsing first
Feeding a PDF blob directly into an LLM context often results in garbled text from parsing artifacts, especially for multi-column or design-heavy resumes. Extract clean plain text first using a library like pdfplumber or PyMuPDF before passing content to the model. Garbage input produces garbage scores.
Ignoring model context length limits
A long resume plus a detailed job description can exceed the context window of smaller open source models, causing the model to silently truncate input. Check token counts before sending. For large batches, consider chunking or summarizing resumes before scoring.
Treating the score as a final decision
AI resume scores are a triage tool, not a hiring decision. Using them as a hard cutoff without human review at some stage increases the risk of systematically excluding qualified candidates whose resumes use different terminology or formatting. Build the score as a sort key, not a gate.
Not logging prompt versions alongside outputs
When you iterate on your prompt, old scores become incomparable to new ones. If you are screening across multiple batches over weeks, version-stamp your prompt and model so you can explain why candidate A got a 74 and candidate B got an 81 when someone asks six months later.
Skipping bias testing on your criteria
If your required criteria include proxies for demographics, such as specific university names or graduation year ranges, the model will faithfully apply those filters and amplify the bias. Audit your job requirements for these patterns before encoding them into a prompt that runs at scale.

Related queries

Frequently asked questions

What open source models work best for resume screening?

Mistral 7B, LLaMA 3 8B, and Qwen2 7B are strong starting points for local deployment. They handle structured extraction and scoring well within typical resume-plus-job-description token counts. For higher accuracy on nuanced role requirements, Mixtral 8x7B or LLaMA 3 70B (if you have the hardware) outperform smaller variants at the cost of inference speed.

Is open source AI resume screening legal?

It depends on your jurisdiction and how you use the output. In the United States, EEOC guidelines apply to any selection tool, including AI. New York City requires bias audits for automated employment decision tools. The EU AI Act classifies recruitment AI as high-risk. Running open source models does not exempt you from these rules. Consult legal counsel before deploying at scale in regulated markets.

Can I run this without sending resumes to an external API?

Yes, that is one of the main reasons to use open source models. Tools like Ollama let you run LLaMA, Mistral, or Gemma locally on a laptop or on-premise server. No candidate data leaves your infrastructure. This is the primary privacy advantage over using GPT-4 or Claude via API.

How accurate is AI resume screening compared to human reviewers?

For hard-skill matching against explicit criteria, well-prompted LLMs are comparable to or faster than a first-pass human screen. They are less reliable for soft-skill inference, cultural fit signals, or roles where the job description is vague. Use AI to sort, and humans to evaluate the top tier.

What is the difference between AI resume screening and traditional ATS keyword matching?

Traditional ATS systems do exact or fuzzy keyword matching, so a resume saying 'Postgres' might miss a search for 'PostgreSQL.' LLMs understand semantic equivalence, so they can recognize that a resume describing 'event streaming with message queues' is relevant to a job requiring 'Kafka experience,' even without the exact term. This reduces false negatives significantly.

How do I handle resumes in languages other than English?

Multilingual models like Qwen2 or Mistral handle common European languages reasonably well. For non-Latin script languages or less-common languages, accuracy drops and you should validate outputs manually on a sample. Alternatively, translate resumes to English first using an open source translation model before running the screening prompt.