DEV Community: Umer Jahangir

AI-Powered Job Matching System with Redis 8

Umer Jahangir — Thu, 07 Aug 2025 08:53:03 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

What I Built

I built a real-time AI-powered job matching system that connects job seekers with the most relevant job opportunities using semantic search, vector similarity, and dynamic AI enrichment.

The system uses:

Redis 8 vector search to match user profiles with job descriptions
AI enrichment uses redis cache to explain and justify the match
Caching in Redis to serve fast and profile-specific job recommendations

Whether you're a frontend developer, backend engineer, or full-stack dev, this platform finds you jobs based on your real skills and experience—not just keyword matching.

Demo

Live Demo:

Source Code:

Umer-Jahangir / AI_JobMatcher

AI-Powered Job Matcher with Redis 8

This project is a smart, real-time job-matching platform that connects users with the most relevant job opportunities using Redis 8 vector search, semantic caching, Django, React, and AI enrichment via gemini key. It delivers a personalized job feed with instant feedback on matched and missing skills — without repeatedly consuming AI tokens.

Demo

What I Built

A real-time AI job matching system that:

Embeds user profiles using SentenceTransformers
Searches semantically similar job vectors stored in Redis 8
Enriches jobs with AI via (Google Gemini Key)
Caches enriched results in Redis to prevent redundant calls
Dynamically updates match analysis (score, skills) based on user profile changes

Tech Stack

Redis 8 – vector similarity search + semantic caching
Django – backend, REST API, Redis integration
React – frontend for job browsing
SentenceTransformers – for job/user embeddings
API KEY – connects to…

View on GitHub

How I Used Redis 8

Redis 8 was the heart of my real-time AI system. Here's how I leveraged its powerful features:

Vector Search (FT.CREATE job_idx)
I encoded both user profiles and job descriptions using sentence-transformer embeddings and stored them as vectors in Redis. When a user logs in or updates their profile, their vector is matched against the job vectors using KNN vector similarity in Redis:

Query("*=>[KNN 20 @embedding $vec AS score]")

This enabled:

Real-time ranking of the most semantically relevant jobs
Scalable search across thousands of job records
Accurate AI-driven matches beyond keyword overlap

Semantic Caching
To improve performance, I cached AI-enriched job match results in Redis using a custom cache key:

user:{user_hash}:profile:{profile_hash}:job:{job_id}:enriched

If a user updated their profile, the profile_hash changed, forcing the system to recompute and cache new, relevant results. This dynamic cache key pattern gave me AI freshness with Redis-level speed.

AI + Redis Combo
For jobs not yet enriched, I used a backend AI model (like DeepSeek or Gemini) to generate:

match_score
matched_skills
missing_skills
AI explanation (Why this job fits the user)

These were then:

Stored back in Redis
Saved to a relational DB (via Django ORM)
Served in milliseconds on the next request

Project Without Redis

Before integrating Redis, the system had multiple inefficiencies:

Static Job Listings: The same set of jobs was shown to users regardless of minor profile updates, unless the AI model was manually rerun.
Redundant API Calls: Every time a user visited the job feed, the system made repeated calls to the AI model to:
Compute match_score
List matched_skills and missing_skills
Generate AI explanations
High Token & Latency Costs: Each AI call consumed tokens and time—making it costly and slow to scale.
No Personalization Memory: The system didn’t remember if a user had already seen or been matched to a job before.
Heavy Backend Load: The database and AI backend handled all logic repeatedly, increasing server strain and user wait time.

Project With Redis

With Redis integrated (using Redis 8’s vector search and smart caching), the system became real-time, cost-effective, and intelligent:

Smart Semantic Caching

Redis stores AI-enriched job data (e.g., match_score, skills, AI explanations) using a profile-aware cache key.
When the user updates their profile (skills, experience, etc.), a new profile hash is created—automatically invalidating old matches and triggering fresh ones only when necessary.
No need to rerun the AI model unless the user profile actually changes, reducing API/token usage dramatically.

Dynamic Job Ranking

Uses Redis 8 vector search (KNN) to fetch only the most relevant jobs from thousands of listings in real time.
Personalized results are sorted by similarity to the user's profile vector—no more hardcoded job lists or random ordering.

Reduced Redundancy & Faster UX

Jobs are enriched with AI once, then stored in Redis and reused.
This eliminates redundant calls and avoids repeatedly fetching, enriching, and saving the same jobs.
Users see fresh, dynamic results instantly—with AI match analysis like:
60% Match
Skills You Have vs. Skills to Develop
Personalized AI explanation

Key Benefit

To dynamically reflect changes in match score, skills you have, and missing skills in your AI Match Analysis without rerunning the AI model, Redis acts as the perfect semantic cache and real-time vector database—making your AI system smarter, faster, and cheaper.

Tech Stack

Redis 8 – for vector search, KNN similarity matching, and semantic caching of enriched job data
Django – as the backend framework handling REST API logic, user management, Redis integration, and AI orchestration
React – for a dynamic frontend where users browse personalized job listings and view AI match analysis
SentenceTransformers – to embed user profiles and job descriptions into high-dimensional vectors for semantic matching
gemini-flash-2.0 API – for generating job match_score, matched_skills, missing_skills, and natural language explanations
*Auth0 *– to handle secure authentication and user identity management across the frontend and backend
Docker– to containerize the entire stack (Redis, Django backend, React frontend) for consistent local development and seamless deployment

Team

Built by @umer_jahangir

Why It Matters

Traditional job search is broken — full of keyword spam and irrelevant results. With Redis and AI combined:

Matching becomes smart and contextual
Users get instant feedback
Systems scale without compromise

Redis 8 made it possible to build a system that feels alive, fast, personalized, and intelligent.

Thanks!

Thanks to the Redis team and DEV community for organizing this challenge.
Redis 8 is truly redefining what's possible in real-time AI applications.

Relief Finder AI – Powered by Algolia MCP

Umer Jahangir — Fri, 25 Jul 2025 10:57:24 +0000

This is a submission for the Algolia MCP Server Challenge.

Inspiration

Disasters like floods, earthquakes, and wildfires leave people vulnerable and disoriented. Getting real-time information about relief shelters, available resources, safety zones, and weather conditions can save lives. I wanted to create an AI-powered assistant that uses Algolia’s MCP tools to make this information searchable, intelligent, and fast.

What It Does

Relief Finder AI is a full-stack disaster response app that:

Lets users search for relief shelters with filters like food, water, and medical aid.
Uses Algolia MCP to intelligently select the right search index.
Offers a chat-based AI assistant to answer user questions naturally.
Displays real-time weather and safety scores for each shelter.
Fetches disaster alerts and shows them on an interactive map.
Fetches Shelter Reliefs and shows them on an interactive ui.

Demo

Source Code: GitHub Repository

Demo Video:

How We Built It

Frontend: React + Algolia InstantSearch + Leaflet + OpenWeather API
Backend: Django + Algolia MCP SDK + OpenRouter AI (AI models)
Data Sources:

Relief_Shelter index in Algolia for shelter info
disaster_alerts index for real-time threats
Weather from OpenWeatherMap API
AI assistant from OpenRouter

MCP Tools Used

searchSingleIndex – Used to search both relief shelters and disaster alerts from the appropriate Algolia index.
algolia_reindex – Used in the backend to import and reindex data dynamically into Algolia indices.
React InstantSearch – Used on the frontend to display and interact with search results using InstantSearch components.
Dynamic Prompt Generation – AI prompt is generated based on user input and current search context.
AI Tool Selection – The backend determines which MCP tool and Algolia index to use based on the user query using an AI model (e.g., DeepSeek/Mistrel).

Challenges We Ran Into

Building a tool-switching logic for AI to decide which index to use
Handling real-time weather and geolocation sync in React
Integrating MCP SDK cleanly with Django backend
Import data to my indexes through the Django backend

What I Learned

How to use Algolia MCP tools like searchSingleIndex and integrate them into a real-world application.
The process of setting up and reindexing Algolia indices from a Django backend using algolia_reindex.
How to build a React InstantSearch UI that connects seamlessly with Algolia for fast, filterable search experiences.
How to integrate AI models (DeepSeek/Mistrel) through OpenRouter and dynamically generate prompts based on user queries.
How to design a tool-selection logic so the AI assistant can choose the right Algolia index and return meaningful, context-aware responses.
How to combine multiple APIs (Algolia, OpenWeatherMap, OpenRouter) into one unified, intelligent disaster response system.

Built with curiosity and determination for the Algolia MCP Server Challenge

Final Year CS Student Exploring Innovative FYP Ideas

Umer Jahangir — Fri, 04 Jul 2025 16:25:47 +0000

Hello everyone!

I'm new to the developer community and truly excited to be a part of it. I’ve joined this space not only to enhance my own skills but also to support and learn from fellow developers.

I’m currently in my final year of BS Computer Science, and I’m looking for guidance, ideas, or suggestions for my Final Year Project (FYP). I want to work on something meaningful, impactful, and ideally aligned with current industry trends or technologies.

If you have any tips, project ideas, or advice from your own experience, I’d really appreciate it. Looking forward to learning, contributing, and growing with this amazing community.

Thank you!