An AI-powered Resume Intelligence platform that allows users to upload a resume, ask questions about the candidate, compare the resume against a Job Description, identify skill gaps, and receive AI-generated improvement suggestions.
The application combines FastAPI, Streamlit, FastEmbed, Hybrid RAG, Groq, Docker, and Render to provide an end-to-end resume analysis experience.
🚀 Try Resume Intelligence AI:
https://resume-intelligence-ai-aman.streamlit.app/
The backend is hosted on Render. The first request may take a short time if the service is waking from an idle state.
- Upload resume files in PDF format
- Extract and process resume content
- Automatically activate the uploaded resume for analysis
- Generate embeddings for resume sections
- Use the uploaded resume for question answering and Job Description analysis
Ask natural-language questions about the uploaded resume.
Example questions:
- What are the candidate's strongest technical skills?
- Summarize the candidate's professional experience.
- What projects has the candidate worked on?
- What database technologies does the candidate know?
- What BI tools does the candidate use?
- What certifications does the candidate have?
The system uses Hybrid Retrieval-Augmented Generation (RAG) to retrieve relevant resume information before generating the answer.
Upload a Job Description and compare its requirements against the currently active resume.
The system provides:
- Rule-based skill match percentage
- Matched skills
- Missing skills
- Skill coverage
- Skill-gap identification
- Resume improvement suggestions
- AI-powered candidate fit analysis
The AI analysis generates:
- Overall Candidate Fit
- Candidate Strengths
- Skill Gaps
- Resume Improvement Suggestions
- Interview Preparation Topics
- Final Recommendation
Upload a resume and ask questions about the candidate using the AI-powered Resume RAG system.
Compare the uploaded resume against a Job Description to identify matched skills, missing skills, and overall compatibility.
Generate detailed AI-powered candidate analysis including strengths, skill gaps, resume improvement suggestions, interview preparation topics, and final recommendations.
┌──────────────────────┐
│ Streamlit UI │
│ app.py │
└──────────┬───────────┘
│
│ HTTP Requests
▼
┌──────────────────────┐
│ FastAPI Backend │
│ api/main.py │
└──────────┬───────────┘
│
┌─────────────────┼─────────────────┐
│ │ │
▼ ▼ ▼
Resume Parser FastEmbed Skill Matching
│ Embeddings │
│ │ │
└────────────► Hybrid RAG ◄───────────┘
│
▼
Groq LLM API
│
▼
AI Generated Response
| Technology | Purpose |
|---|---|
| Python | Core application development |
| Streamlit | Frontend user interface |
| FastAPI | REST API backend |
| FastEmbed | Resume embedding generation |
| Hybrid RAG | Resume information retrieval |
| Groq | LLM inference |
| Docker | Backend containerization |
| Render | FastAPI backend deployment |
| Streamlit Community Cloud | Frontend deployment |
| GitHub | Version control and deployment integration |
Resume_Intelligence_AI/
│
├── api/
│ └── main.py
│
├── src/
│ ├── embeddings.py
│ ├── retriever.py
│ ├── agent.py
│ └── ...
│
├── Data/
│ └── Resume/
│
├── evaluation/
│
├── tests/
│
├── app.py
├── Dockerfile
├── requirements.txt
└── README.md
The FastAPI backend provides the following endpoints:
| Method | Endpoint | Description |
|---|---|---|
GET |
/ |
API root |
GET |
/health |
Check API and model health |
POST |
/upload-resume |
Upload and process a resume |
POST |
/ask |
Ask questions about the active resume |
POST |
/analyze-job-description |
Compare the resume with a Job Description |
Interactive FastAPI documentation is available through:
/docs
git clone https://github.com/amandadhich18/Resume_Intelligence_AI.git
cd Resume_Intelligence_AIpython -m venv .venvWindows PowerShell:
.venv\Scripts\Activate.ps1Windows Command Prompt:
.venv\Scripts\activateLinux/macOS:
source .venv/bin/activatepip install -r requirements.txtCreate a .env file in the project root.
Add your Groq API key:
GROQ_API_KEY=your_groq_api_keyImportant: Never commit your
.envfile or API keys to GitHub.
Start the backend with:
uvicorn api.main:app --reloadThe API will normally be available at:
http://127.0.0.1:8000
FastAPI Swagger documentation:
http://127.0.0.1:8000/docs
Open another terminal and run:
streamlit run app.pyThe Streamlit application will normally open at:
http://localhost:8501
The FastAPI backend can also be run using Docker.
docker build -t resume-intelligence-ai .docker run --env-file .env -p 8000:8000 --name resume-ai-api resume-intelligence-aiThe containerized API will then be available at:
http://localhost:8000
The project uses separate frontend and backend deployments.
The FastAPI backend is:
- Containerized using Docker
- Deployed on Render
- Responsible for resume processing, embeddings, retrieval, skill matching, and LLM communication
The Streamlit frontend is:
- Built using Streamlit
- Deployed using Streamlit Community Cloud
- Connected to the production FastAPI backend
User
│
▼
Streamlit Community Cloud
│
▼
FastAPI API on Render
│
┌────────────┼────────────┐
│ │ │
▼ ▼ ▼
Resume Parser FastEmbed Skill Matching
│ │ │
└────────────┼────────────┘
▼
Hybrid RAG
│
▼
Groq LLM
│
▼
Generated Response
1. User uploads Resume PDF
↓
2. Resume text is extracted and processed
↓
3. Resume is divided into relevant sections
↓
4. Embeddings are generated using FastEmbed
↓
5. Resume becomes the active resume
↓
6. User asks a question
↓
7. Hybrid RAG retrieves relevant resume sections
↓
8. Retrieved context is provided to the LLM
↓
9. Groq generates the contextual answer
Resume + Job Description
│
▼
Skill Extraction
│
▼
Skill Comparison
│
▼
┌───────────────────┐
│ Matched Skills │
│ Missing Skills │
└─────────┬─────────┘
│
▼
Match Percentage
│
▼
Skill Gap Analysis
│
▼
AI Fit Analysis
│
▼
Improvement Suggestions
│
▼
Interview Preparation
The application currently supports:
- ✅ Resume PDF processing
- ✅ Dynamic resume upload
- ✅ Resume question answering
- ✅ FastEmbed embeddings
- ✅ Hybrid resume retrieval
- ✅ Retrieval-Augmented Generation
- ✅ Job Description upload
- ✅ Job Description analysis
- ✅ Technical skill extraction
- ✅ Resume ↔ JD skill matching
- ✅ Match percentage calculation
- ✅ Skill-gap identification
- ✅ Resume improvement recommendations
- ✅ AI candidate-fit analysis
- ✅ Interview preparation recommendations
- ✅ FastAPI REST API
- ✅ Streamlit web interface
- ✅ Dockerized backend
- ✅ Render backend deployment
- ✅ Streamlit Community Cloud frontend deployment
Suppose a Job Description requires:
Python
SQL
Power BI
Tableau
Excel
Data Analysis
Data Visualization
The application analyzes the active resume and separates the requirements into:
Skills found in both the resume and Job Description.
Skills detected in the Job Description but not explicitly detected in the resume.
The application then calculates a rule-based skill match percentage and uses the LLM to perform a broader candidate-fit analysis.
This distinction helps avoid treating exact keyword overlap and AI-based contextual evaluation as the same measurement.
The AI-powered Resume ↔ Job Description analysis can provide:
An overall assessment of how closely the candidate aligns with the Job Description.
Highlights relevant technical skills, projects, tools, and experience.
Identifies requirements that are missing or weakly represented in the resume.
Provides practical recommendations for improving alignment with the target role.
Suggests technical and business topics that the candidate should prepare for.
The candidate can be classified as:
- Strong Fit
- Good Fit
- Partial Fit
- Low Fit
Potential future improvements include:
- Support for DOCX resumes
- Multiple resume comparison
- Semantic Job Description skill matching
- ATS compatibility scoring
- Resume scoring dashboard
- Resume keyword recommendations
- Improved skill taxonomy
- Candidate ranking
- Persistent vector database
- User authentication
- Resume analysis history
- Exportable PDF analysis reports
- Advanced evaluation pipeline
- Automated resume improvement recommendations
- Multi-candidate recruitment dashboard
The goal of Resume Intelligence AI is to demonstrate how modern Data Analytics, Generative AI, Retrieval-Augmented Generation, API development, and cloud deployment technologies can be combined to build a practical resume intelligence application.
The project combines:
Resume Processing
+
Embedding Generation
+
Hybrid Retrieval
+
Skill Matching
+
Retrieval-Augmented Generation
+
LLM Analysis
+
FastAPI
+
Streamlit
+
Docker
+
Cloud Deployment
into a complete end-to-end AI application.
Data Analyst | Generative AI (GenAI) Enthusiast
Passionate about building data-driven and AI-powered solutions using Python, SQL, Power BI, Machine Learning, RAG, and Generative AI.
If you find this project useful, consider giving the repository a ⭐ Star on GitHub.
Contributions, suggestions, and feedback are welcome.