How harshith051104/automated-resume-relevance-check-system works
This is a single-repo Python application with a Streamlit UI that orchestrates an AI/NLP evaluation pipeline to score resume relevance vs job descriptions. It’s not a traditional multi-tier “frontend/backend” web app; instead it’s a UI-driven orchestration layer (Streamlit) calling modular Python components:
• Parsers: extract structured text/skills from PDF/DOCX JDs and resumes
• Scoring engine: combines hard/lexical matching + semantic/embedding matching
• LLM pipeline: uses LangChain + LangGraph with Google Gemini (and LangSmith tracing)
• Persistence: SQLite via SQLAlchemy for JDs/resumes/results
• Vector store: ChromaDB for semantic search/embeddings (per README)
Entry/UI
• app.py — Streamlit application entrypoint; page routing/workflow; invokes parsing/scoring; renders analytics.
Core modules (under src/)
• src/parsers/
• jd_parser.py — JD ingestion/parse pipeline (PDF/DOCX → text/entities/skills)
• resume_parser.py — Resume ingestion/parse pipeline (PDF/DOCX → text/entities/skills); mentions NLTK in README
• src/scoring/
• score_engine.py — orchestrates scoring; merges sub-scores into final weighted score
• hard_match.py — keyword/BM25/fuzzy/TF-IDF style matching (lexical signals)
• semantic_match.py — embeddings/semantic similarity; integrates ChromaDB + Google embeddings (per README)
• src/langchain_pipeline/
• chains.py — LangChain chain definitions (prompting / tools / retrieval steps)
• graph.py — LangGraph orchestration (state machine / DAG for multi-step evaluation)
• src/database/
• db_handler.py — database access layer (SQLAlchemy) for SQLite persistence
• src/utils/helpers.py — shared helpers used across modules
Config/Runtime
• .streamlit/config.toml — UI settings/theme
• .env.example — env var contract: Gemini key, LangSmith settings, DB URL, limits
• requirements.txt, packages.txt, .devcontainer/ — dependency + deployment scaffolding
From README/env contract, treat these as “outside the system” but connected:
• User (Recruiter/HR) via browser
• Streamlit runtime (hosting: local or Streamlit Cloud)
• Google Gemini API (LLM inference)
• Google AI Embeddings API (semantic embeddings) *(or whichever LangChain embeddings provider configured)*
• LangSmith (observability/tracing)
• File inputs (PDF/DOCX uploads) — treat as data source from user session
Upload resume(s) → parse → persist
3) For each resume × JD: build evaluation context → run hard + semantic scoring → combine → store result → render dashboard
Primary flows
(1) JD ingestion path
• User → app.py (Upload JD PDF/DOCX)
• app.py → src/parsers/jd_parser.py (extract text/skills/entities)
• jd_parser.py → src/database/db_handler.py (store JD raw text + extracted fields)
• db_handler.py → SQLite
(2) Resume ingestion path
• User → app.py (Upload Resume PDF/DOCX)
• app.py → src/parsers/resume_parser.py
• resume_parser.py → db_handler.py → SQLite
(3) Evaluation/scoring path
• app.py → src/scoring/score_engine.py (evaluate resume vs JD)
• score_engine.py → hard_match.py (TF-IDF/BM25/fuzzy signals)
• score_engine.py → semantic_match.py:
• semantic_match.py → Embeddings API (create embeddings)
• score_engine.py → src/langchain_pipeline/graph.py (if LLM reasoning is in the loop)
• graph.py → chains.py
• chains.py → Google Gemini API
• langchain_pipeline/* → LangSmith (trace spans, prompts, runs)
• score_engine.py → db_handler.py → SQLite (persist evaluation results, scores, verdicts)
(4) Analytics/dashboard path
• app.py → db_handler.py → SQLite (read results)
• app.py → UI Charts (score distributions/trends)
Cross-cutting concerns to label (don’t hide them)
• Env/config: .env values feed app.py and pipeline modules (API keys, DB URL, limits)
Small annotation callouts (sticky-note style) to make design intent explicit:
• Orchestrator pattern: app.py is the central coordinator; business logic is in src/.
• Separation of concerns:
• parsing (src/parsers)
• scoring (src/scoring)
• LLM orchestration (src/langchain_pipeline)
• persistence (src/database)
• Hybrid scoring strategy: lexical + semantic + optional LLM reasoning (weighted final score).
• Observability: LangSmith instrumentation around LangChain/LangGraph runs.
• Stateful stores: SQLite (structured persistence) + ChromaDB (vector persistence).
Nodes explicitly:
• app.py (Streamlit UI + workflow)
• src/parsers/jd_parser.py
• src/parsers/resume_parser.py
• src/scoring/score_engine.py
• src/scoring/hard_match.py
• src/scoring/semantic_match.py
• src/langchain_pipeline/graph.py
• src/langchain_pipeline/chains.py
• src/database/db_handler.py
• SQLite DB file (DATABASE_URL=sqlite:///...)
• ChromaDB (vector store)
• Google Gemini API
• Embeddings API
• LangSmith
• Config: .env / Streamlit Secrets, .streamlit/config.toml
• Batch processing loop (annotated)