devLap

Building a Smarter Hiring Engine: AI Recruiter with RAG, Memory & Web Search

python dev.to

This is a submission for Weekend Challenge: Earth Day Edition

Background

What I Built

Recruit Intelligence Agent is an AI-powered recruitment assistant that streamlines hiring through:

  • Automated candidate screening
  • Resume parsing
  • Job description matching
  • Candidate validation via live web search

It goes beyond traditional ATS systems by combining RAG, memory, web search, and reasoning into a single intelligent workflow powered by BackBoard

Overview

Recruit Intelligence Agent is a production-ready AI-powered recruitment API built with FastAPI and Backboard. It streamlines the hiring process through automated candidate screening, resume parsing into standardized JSON Resume format, intelligent job matching with gap analysis, job description generation with market research, and candidate validation via live web searches.

Key capabilities:

  • Parse resumes (Backboard supported files) into structured JSON Resume format
  • Evaluate candidates against job descriptions with scoring and analysis
  • Perform deep agentic reasoning with multi-step analysis pipelines
  • Validate candidate work history and credentials via web search
  • Research skill market trends and salary ranges
  • Generate optimized, inclusive job descriptions
  • Analyze team composition for skill gaps
  • General document Q&A and summarization

Core Features

Resume Parsing

Extracts structured JSON Resume data from the supported file types:

  • Basics (name, email, summary)
  • Work history
  • Education
  • Skills
  • Projects
  • Certifications

Supported File Types

Category Extensions
Documents .pdf, .doc, .docx, .ppt, .pptx, .xls, .xlsx
Text / Data .txt, .csv, .md, .markdown, .json, .jsonl, .xml
Images .png, .jpg, .jpeg, .webp, .gif, .bmp, .tiff, .tif

Candidate Evaluation

  • Scores candidates against job descriptions

  • Identifies:

    • Skill gaps
    • Transferable skills
    • Risk factors

Agentic Reasoning

Multi-step pipeline:

  1. Parse resume
  2. Extract skills
  3. Research market demand
  4. Analyze job fit
  5. Validate claims

Web Search Validation

  • Verifies candidate profiles
  • Validates company work history
  • Research skill trends

Memory-Enabled Reasoning

  • Stores candidate details automatically
  • Improves future evaluations
  • Enables contextual decision-making

Document Q&A

Ask questions about resumes and get contextual answers.

Job Description Generator

  • Generates optimized and inclusive JDs

  • Includes:

    • Responsibilities
    • Skills
    • Market insights
    • Inclusivity checks

Demo

Run locally with FastAPI and accessing the API documentation:

Generate Job Description

Summarization

Parse Resume Document

Quick Start

The application supports two modes of operation:

Mode 1: Stateful (Recommended for multiple operations on same document)

# Step 1: Upload a document
curl -X POST http://localhost:8000/upload -F file=@resume.pdf

# Response: {"thread_id": "thread_xxx", "status": "indexed"}

# Step 2: Use thread_id for all subsequent calls
curl -X POST http://localhost:8000/parse -F thread_id=thread_xxx
curl -X POST http://localhost:8000/evaluate -F thread_id=thread_xxx -F job_description="Senior Python Developer with Django, PostgreSQL experience..."
curl -X POST http://localhost:8000/comprehensive_evaluate -F thread_id=thread_xxx -F job_description="Senior Python Developer..."
Enter fullscreen mode Exit fullscreen mode

Mode 2: Fallback (Single operation, creates new session each time)

# Direct file upload - no need to manage document_id/thread_id
curl -X POST http://localhost:8000/parse -F file=@resume.pdf
curl -X POST http://localhost:8000/evaluate -F file=@resume.pdf -F job_description="Senior Python Developer..."
Enter fullscreen mode Exit fullscreen mode

Code

GitHub Repository:
https://github.com/ranjancse26/recruit_intelligence_agent

Installation

  1. Clone the repository and navigate to the project directory

  2. Create and activate a virtual environment:

    • Windows: venv\Scripts\activate
    • Linux/Mac: source venv/bin/activate

  3. Install dependencies:
    pip install -r requirements.txt

  4. Configure environment variables in .env file:
    BACKBOARD_API_KEY=your_api_key_here
    BACKBOARD_LLM_PROVIDER=openai
    BACKBOARD_MODEL_NAME=gpt-5-mini
    BACKBOARD_TIMEOUT=1800

Running the Application

uvicorn app.main:app --reload

Endpoint Examples

Parse Resume (JSON Resume format)

curl -X POST http://localhost:8000/parse -F thread_id=thread_xxx
Enter fullscreen mode Exit fullscreen mode

Returns structured resume data with basics, work, education, skills, projects, etc.

Evaluate Candidate

curl -X POST http://localhost:8000/evaluate \
  -F thread_id=thread_xxx \
  -F job_description="Senior Python Developer with 5+ years experience in Django, FastAPI, PostgreSQL, AWS"
Enter fullscreen mode Exit fullscreen mode

Returns score, strengths, gaps, risk flags, and recommendation.

Comprehensive Agentic Evaluation

curl -X POST http://localhost:8000/comprehensive_evaluate \
  -F thread_id=thread_xxx \
  -F job_description="Senior Python Developer..."
Enter fullscreen mode Exit fullscreen mode

Performs full pipeline: resume parsing → skill extraction → market research → job fit analysis → validation.

Summarize Document

curl -X POST http://localhost:8000/summarize -F thread_id=thread_xxx
Enter fullscreen mode Exit fullscreen mode

Reason on Document

curl -X POST http://localhost:8000/reasoning \
  -F thread_id=thread_xxx \
  -F question="What are the candidate's leadership experiences?"
Enter fullscreen mode Exit fullscreen mode

Q&A

curl -X POST http://localhost:8000/qa \
  -F thread_id=thread_xxx \
  -F question="What Python frameworks has the candidate used?"
Enter fullscreen mode Exit fullscreen mode

Web Search for Candidate

# General search
curl -X POST http://localhost:8000/websearch \
  -F thread_id=thread_xxx \
  -F query="John Doe Python developer GitHub"

# Search with known details
curl -X POST http://localhost:8000/websearch \
  -F name="John Doe" \
  -F email="john@example.com" \
  -F company="Google"
Enter fullscreen mode Exit fullscreen mode

Validate Candidate Profile

curl -X POST http://localhost:8000/validate \
  -F name="John Doe" \
  -F email="john@example.com" \
  -F company="Google"
Enter fullscreen mode Exit fullscreen mode

Validate All Companies from Resume

curl -X POST http://localhost:8000/validate-companies \
  -F thread_id=thread_xxx
Enter fullscreen mode Exit fullscreen mode

Generate Job Description

curl -X POST http://localhost:8000/jd/generate \
  -F role_requirements="Senior Python Developer with Django, FastAPI, PostgreSQL experience. 5+ years of backend development."
Enter fullscreen mode Exit fullscreen mode

Research Role Market Trends

curl -X POST http://localhost:8000/jd/research-trends \
  -F role="Software Engineer" \
  -F industry="Technology"
Enter fullscreen mode Exit fullscreen mode

Analyze Existing Team

curl -X POST http://localhost:8000/jd/analyze-team \
  -F team_composition_json='[{"role": "Frontend Developer", "skills": ["React", "TypeScript"], "experience": 3}, {"role": "Backend Developer", "skills": ["Python", "Django"], "experience": 5}]'
Enter fullscreen mode Exit fullscreen mode

How I Built It

Tech Stack

  • Python 3.8+
  • FastAPI
  • Backboard SDK
  • Pydantic
  • python-multipart

Architecture 

recruit_intelligence_agent/
├── app/
│   ├── main.py
│   ├── routes.py
│   ├── core/
│   │   └── monitoring.py
│   ├── services/
│   │   └── backboard_client.py
│   └── tools/
│       ├── reasoning_tools.py
│       ├── resume_tools.py
│       ├── candidate_websearch.py
│       ├── jd_generator.py
│       └── resume_schema.json
├── requirements.txt
├── .env
└── README.md
Enter fullscreen mode Exit fullscreen mode

Key Technical Decisions

1. Backboard Integration

  • Document upload with indexing
  • Thread-based conversations
  • Memory-enabled reasoning
  • Web search integration

2. JSON Resume Schema 

{
  "basics": {
    "name": "",
    "label": "",
    "email": "",
    "phone": "",
    "url": "",
    "summary": "",
    "location": {
      "address": "",
      "city": "",
      "region": "",
      "postalCode": "",
      "countryCode": ""
    },
    "profiles": []
  },
  "work": [
    {
      "name": "",
      "position": "",
      "url": "",
      "startDate": "",
      "endDate": "",
      "summary": "",
      "highlights": []
    }
  ],
  "education": [
    {
      "institution": "",
      "area": "",
      "studyType": "",
      "startDate": "",
      "endDate": "",
      "score": "",
      "courses": []
    }
  ],
  "skills": [
    {
      "name": "",
      "level": "",
      "keywords": []
    }
  ],
  "projects": [
    {
      "name": "",
      "description": "",
      "highlights": [],
      "keywords": []
    }
  ],
  "awards": [],
  "certificates": [],
  "publications": [],
  "languages": [],
  "interests": [],
  "references": [],
  "meta": {}
}
Enter fullscreen mode Exit fullscreen mode

3. Agentic Reasoning Pipeline

  • Step 1: Resume parsing
  • Step 2: Skill extraction
  • Step 3: Market research
  • Step 4: Job fit scoring
  • Step 5: Validation

4. Memory Layer

  • Stores candidate summaries
  • Enables better future decisions

5. Dual Mode Operation

  • Stateful mode with thread + document IDs
  • Stateless fallback mode

API Endpoints

Endpoint Description
POST /upload Upload document
POST /parse Parse resume
POST /evaluate Evaluate candidate
POST /comprehensive_evaluate Full reasoning pipeline
POST /summarize Summarize document
POST /reasoning Run reasoning
POST /qa Ask questions
POST /websearch Web search
POST /validate Validate profile
POST /validate-companies Validate companies
POST /jd/generate Generate JD
POST /jd/research-trends Market trends
POST /jd/analyze-team Team analysis

Job Description Generator

  • Inclusive language checks
  • Clarity scoring
  • Market trend integration
  • Skill gap analysis

Interesting Implementation Details

  • Document polling until indexed
  • Schema-driven parsing
  • Graceful error handling
  • Company validation via web search
  • Skill demand analysis

Prize Category

Best Use of Backboard

  • Document processing
  • Memory-enabled reasoning
  • Web search integration
  • Agentic workflows

Summary

Recruit Intelligence Agent is an AI-powered hiring assistant built on Backboard that transforms traditional recruitment into an intelligent, data-driven process.

It combines document understanding (RAG), persistent memory, real-time web search, and multi-step reasoning to go beyond keyword-based screening and enable true candidate evaluation.

The agent can:

  • Parse resumes into structured intelligence
  • Match candidates to job descriptions with context awareness
  • Validate candidate profiles using live web data
  • Perform reasoning-based scoring with explainable insights

Unlike conventional ATS systems, it doesn't just filter resumes — it understands experience, identifies transferable skills, and makes informed hiring recommendations.

The result is:

  • Faster screening
  • Better candidate fit
  • Smarter, explainable hiring decisions

Built with ❤️ for the Earth Day Hackathon 2026

Source: dev.to

arrow_back Back to Tutorials