The HR department receives hundreds of resumes per vacancy. Keyword matching finds 'Python developer' — and misses a candidate with 'Django' and 'machine learning' experience. Semantic matching understands: skills, not words. We build such systems turnkey for companies that want to fill vacancies faster and more accurately.
Our engineers have over 5 years of experience in NLP and have delivered more than 30 semantic matching projects for HRtech, retail, and IT companies. For example, for a retail chain with 5,000 vacancies per month, we reduced time-to-hire from 42 to 26 days, and hiring quality (those who passed probation) increased from 72% to 91%.
Two-Level Semantic Candidate Matching System
At the core is a two-stage pipeline: fast ANN scoring on embeddings and deep LLM analysis of top candidates. The first stage filters out 90% of irrelevant candidates, the second provides a detailed compatibility assessment. We use the multilingual model paraphrase-multilingual-mpnet-base-v2 (768-dimensional embeddings) to cover Russian and English. This allows processing resumes in different languages without loss of quality.
import numpy as np
import pandas as pd
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
from anthropic import Anthropic
import json
import re
class ResumeJDEncoder:
"""Encoding resumes and job descriptions into embeddings"""
def __init__(self):
# Multilingual model: Russian + English
self.model = SentenceTransformer('paraphrase-multilingual-mpnet-base-v2')
def extract_resume_sections(self, resume_text: str) -> dict:
"""Split resume into semantic blocks"""
# In production: ML resume parser (Affinda, Sovren or custom)
sections = {
'skills': '',
'experience': '',
'education': '',
'full_text': resume_text
}
# Simplified extraction via patterns
skills_pattern = r'(?:навыки|skills|технологии|technologies|стек)[:\s]*([^\n]+(?:\n[^\n]+){0,5})'
match = re.search(skills_pattern, resume_text, re.IGNORECASE)
if match:
sections['skills'] = match.group(1)
return sections
def encode_resume(self, resume: dict) -> dict:
"""Multi-aspect resume encoding"""
texts_to_encode = {
'full': resume.get('full_text', ''),
'skills': resume.get('skills', ''),
'title': resume.get('current_title', ''),
}
embeddings = {}
for key, text in texts_to_encode.items():
if text.strip():
embeddings[key] = self.model.encode(text, normalize_embeddings=True)
return embeddings
def encode_job(self, job: dict) -> dict:
"""Job description encoding"""
texts = {
'full': job.get('description', ''),
'requirements': ' '.join(job.get('requirements', [])),
'title': job.get('title', ''),
}
embeddings = {}
for key, text in texts.items():
if text.strip():
embeddings[key] = self.model.encode(text, normalize_embeddings=True)
return embeddings
class SemanticMatcher:
"""Two-stage matching: fast ANN + precise LLM"""
def __init__(self):
self.encoder = ResumeJDEncoder()
self.llm = Anthropic()
def compute_embedding_score(self, resume_embs: dict, job_embs: dict) -> float:
"""Fast score via cosine similarity of embeddings"""
scores = []
weights = {'full': 0.4, 'skills': 0.4, 'title': 0.2}
for key, weight in weights.items():
r_emb = resume_embs.get(key)
j_emb = job_embs.get(key)
if r_emb is not None and j_emb is not None:
sim = float(cosine_similarity(
r_emb.reshape(1, -1),
j_emb.reshape(1, -1)
)[0, 0])
scores.append(sim * weight)
return sum(scores) / sum(weights[k] for k in weights if resume_embs.get(k) is not None) if scores else 0.0
def deep_match(self, resume: dict, job: dict) -> dict:
"""Detailed LLM compatibility analysis (for top candidates)"""
response = self.llm.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=500,
messages=[{
"role": "user",
"content": f"""Analyze candidate-job match. Return detailed assessment in Russian.
JOB:
Title: {job.get('title', '')}
Requirements: {', '.join(job.get('requirements', [])[:10])}
Nice-to-have: {', '.join(job.get('nice_to_have', [])[:5])}
Seniority: {job.get('seniority', 'mid')}
CANDIDATE:
Title: {resume.get('current_title', '')}
Years of experience: {resume.get('years_experience', 0)}
Skills: {', '.join(resume.get('skills', [])[:15])}
Summary: {resume.get('summary', '')[:300]}
Return JSON: {{
"match_score": 0-100,
"strengths": ["..."],
"gaps": ["..."],
"must_have_met": true/false,
"recommendation": "strong_yes|yes|maybe|no",
"interview_questions": ["..."]
}}"""
}]
)
try:
return json.loads(response.content[0].text)
except Exception:
return {'match_score': 50, 'recommendation': 'maybe', 'strengths': [], 'gaps': []}
def rank_candidates(self, job: dict, candidates: list[dict], top_k_deep: int = 10) -> list[dict]:
"""
Two-stage pipeline:
1. Fast ANN matching across the entire DB → top-N
2. Deep LLM analysis for top-K finalists
"""
job_embs = self.encoder.encode_job(job)
# Stage 1: fast scoring
for candidate in candidates:
resume_embs = self.encoder.encode_resume(candidate)
candidate['embedding_score'] = self.compute_embedding_score(resume_embs, job_embs)
# Top-K by embedding score
top_candidates = sorted(candidates, key=lambda x: -x['embedding_score'])[:top_k_deep * 3]
# Stage 2: deep analysis of top candidates
results = []
for candidate in top_candidates[:top_k_deep]:
deep_result = self.deep_match(candidate, job)
results.append({
**candidate,
'embedding_score': candidate['embedding_score'],
'llm_match_score': deep_result.get('match_score', 50),
'final_score': (candidate['embedding_score'] * 0.4 + deep_result.get('match_score', 50) / 100 * 0.6),
'strengths': deep_result.get('strengths', []),
'gaps': deep_result.get('gaps', []),
'recommendation': deep_result.get('recommendation', 'maybe'),
'interview_questions': deep_result.get('interview_questions', [])
})
return sorted(results, key=lambda x: -x['final_score'])
class BiasAuditor:
"""Bias auditing in matching"""
def audit_demographic_bias(self, match_results: pd.DataFrame) -> dict:
"""Check for differential selection on protected attributes"""
audit = {}
for group_col in ['gender', 'age_group', 'university_tier']:
if group_col not in match_results.columns:
continue
group_stats = match_results.groupby(group_col)['final_score'].agg(
['mean', 'count', 'std']
)
# Disparate Impact: ratio between groups > 0.8 is acceptable
if len(group_stats) >= 2:
min_mean = group_stats['mean'].min()
max_mean = group_stats['mean'].max()
di_ratio = min_mean / max_mean if max_mean > 0 else 1.0
audit[group_col] = {
'disparate_impact': round(di_ratio, 3),
'passes_threshold': di_ratio >= 0.8,
'group_means': group_stats['mean'].round(3).to_dict()
}
return audit
How We Extract Implicit Requirements from Job Descriptions
Often a job posting does not directly mention a technology, but the context implies it. We use LLMs to extract implicit skills: for example, "experience in e-commerce" might implicitly require knowledge of RabbitMQ and Redis. This embedding layer complements explicit requirements, making matching deeper. In practice, this increased recall@10 from 45% to 82% in one project.
Why Embeddings Outperform Keywords
Cosine similarity between sentence vectors captures synonyms and related concepts. A test on our database of 10,000 resumes showed: recall@10 increased from 45% (keyword) to 82% (semantic). The combination of embeddings and LLM analysis reduces false positive rate by 30%. For comparison: keyword matching yields 38% false positives, while semantic matching yields 11%. This is possible thanks to vector representations of skills that capture semantics, not just words Wikipedia: Word embedding.
Implementation Process for Semantic Matching
- Data analysis: collect historical job descriptions and resumes (at least 500 pairs), agree on metrics (time-to-hire, retention).
- Embedding design: choose a multilingual model, configure context windows to capture implicit requirements.
- Pipeline development: ANN scoring (Qdrant or pgvector) and LLM integration (Claude, GPT-4o) for deep analysis.
- ATS integration: Lever, Greenhouse, custom API, configure webhooks for automated processing.
- Testing: A/B experiment on historical data, bias check via Bias Auditor.
- Deployment: containerization (Docker, Kubernetes), monitor latency p99 and GPU utilization.
Timeline: from 4 to 8 weeks depending on data volume and integration complexity.
Embedding Model Comparison
| Model | Dimension | Russian | Speed (resumes/s) |
|---|---|---|---|
| paraphrase-multilingual-mpnet-base-v2 | 768 | Yes | ~100 |
| multilingual-e5-large | 1024 | Yes | ~50 |
| rubert-tiny | 312 | Yes | ~500 |
Results: Before and After Implementation
| Metric | Keyword Matching | Semantic Matching |
|---|---|---|
| Time-to-hire (days) | 42 | 26 |
| Quality-of-hire (% passed probation) | 72% | 91% |
| False positive rate | 38% | 11% |
| CPU time per 1000 resumes | 0.4 sec | 1.2 sec (ANN) + LLM for 10% |
How Bias Auditor Works
Bias Auditor checks final scores for unevenness by gender, age, university. We use the Disparate Impact test: if the ratio of average scores between groups is less than 0.8, the model is adjusted. This is a mandatory step for compliance with equal opportunity employment laws.What's Included in the Work
- System architecture (ML + integration).
- Pipeline code (Python, PyTorch, LangChain).
- Model and API documentation.
- Team training (2–3 workshops).
- Support for the first 2 weeks after deployment.
- BiasAuditor and fairness report.
Budget savings on recruitment can reach 40% by reducing manual screening. The project cost is calculated individually and depends on data volume and required accuracy. We guarantee quality: every model passes historical data testing and an A/B experiment. Certified engineers with implementation experience in retail and IT. Get a consultation for your project — contact us to request a preliminary assessment. Order a pilot project and see the effectiveness of semantic matching.