.NET 8 & AI in Action: Building a Real-World Resume Screener

Create a .env with Postgres and RabbitMQ credentials, OpenAI api key, and internal service URLs; define docker compose service names and front-end, api, and ai worker origins.

Set up docker and Postgres initialization with an init sql script, creating jobs, candidates, embeddings, and rankings tables with pg vector and uuid support.

Create a docker-compose setup linking Postgres, RabbitMQ, a .NET 8 core API, a Python AI worker using OpenAI, and a React frontend with env vars, health checks, and port mappings.

Create a dotnet 8 dockerfile for core api, use docker compose to build, copy source, restore and publish, set work directory, expose port 8080, and specify the dll entry point.

Create a Python AI worker dockerfile for the AI worker project. Install dependencies from requirements.txt, copy the app, expose port 8000, and run unicorn with entry point app.main as worker.

Create a Dockerfile for a React app using node 20 alpine, install dependencies, copy project files, expose port 5173, and run the dev server on 0.0.0.0.

Design and develop an AI worker that handles vector embeddings in Postgres and interfaces with the OpenAI API, using a Python-based FastAPI setup and a requirements.txt for dependencies.

Create config.py in the core ai worker, define a settings class with database url, rabbitmq url, open ai key, and web origin using os.getenv, then export settings.

Build a Postgres backend connection helper with SQLAlchemy and psycopg2, creating an engine, setting up an on connect vector registration, and providing execute, fetch all, and fetch one utilities.

Create an OpenAI client helper in the AI worker services, initialize the client from settings, raise an error if the API key is missing, enabling embeddings, chat, images, and video.

Create an embeddings service using the OpenAI client, defining embeddings.py, and implement embed text to return 1536-dim vectors via the text embedding three small model.

Implement a rabbitmq consumer using the OpenAI client to create vector embeddings for resumes, with two queues: resume parse and rank refresh in an AI worker.

Develop a resume parser handler that creates embeddings from resumes, upserts them into the embeddings table, and updates the candidate's resume text in the database.

Build a refresh rankings handler that creates job embeddings, computes candidate resume similarities, prompts OpenAI to justify matches, and upserts rankings for real-time screening.

The main.py kickoff configures a FastAPI AI worker, enables CORS, and starts a RabbitMQ consumer thread on startup, with a health check and Docker logs during startup.

Run and test the docker compose setup to initialize rabbitmq, postgres, and the ai worker locally. Verify containers and ports, and confirm the resume screener database schema and extensions.

Configure the core api in dotnet 8 by creating the csproj, enabling nullable and implicit usings, and wiring domain, application, and infrastructure references with swagger, dapper, and postgres packages.

Copy and configure core application csproj, reference domain project from the application layer, reference infrastructure, remove the extra application reference, and set the api to depend on the application.

Create a core domain project file to host the domain entity and dtos, referencing dotnet eight, and set up a csproj for the core domain.

Set up the core infrastructure project by creating infrastructure.csproj, wiring package references for Dapper, Npgsql, RabbitMQ client, and Microsoft.Extensions.Configuration extensions, and validate project references and end tags.

Configure appsettings.json with Postgres and RabbitMQ connection strings, core allowed origins for a react app on 5173, and logging levels to support the resume screener.

Implement a Postgres connection factory that implements an IDB connection factory interface, retrieves the default connection string from app settings, and opens the connection asynchronously.

Implement a rabbit publisher in dotnet eight to publish messages to RabbitMQ, using exchange name, routing key, and message body, with queues resume.parse and rank_refresh and logging.

Design the domain layer of the real-world resume screener by defining core entities—candidates, jobs, rankings, messages, and metrics—and implementing create candidate and create job requests, RabbitMQ messages, and ranking dtos.

Define application layer interfaces for candidate, job, metrics, rankings, and seed services, enabling async create and list operations and rankings refresh.

Implement the candidate service by wiring Postgres insertion, RabbitMQ publishing for resume parsing, and AI embeddings, with logging and a candidates listing capability.

Implement a jobs service in .NET 8 that creates and lists jobs for the resume screener, using a Postgres connection with Dapper, logging, and SQL inserts into the jobs table.

Implement a metric service that queries counts from candidates, jobs, and rankings using Dapper and a Postgres connection, with dependency injection and logging for metrics retrieval.

Implement a rankings service that retrieves candidate rankings for a job from the database and publishes a rank refresh message to RabbitMQ for the AI worker to re-evaluate using OpenAI.

Implement a seed service to populate database with a sample senior back end engineer job and three candidates using dapper, inserting job and candidate rows and returning the seeded ids.

Finish wiring a .NET 8 core API by configuring program.cs to inject services, build app, enable swagger and CORS with origin from app settings, and register infrastructure and application services.

Create a health controller, inject the db connection factory, and implement an http get health check that executes a simple select one query to verify database health.

Create a candidates controller in a restful web api by injecting the candidate service to handle post create and get list operations, keeping business logic in the service layer.

Implement a streamlined jobs controller in ASP.NET Core MVC, exposing create and list endpoints, injecting the job service, and wiring routes for a React dashboard.

Implement a metrics controller in .NET 8, inject the metrics service, expose a get metrics route, and return a metrics response with counts of jobs, candidates, and rankings.

Implement a rankings controller with a get route to retrieve rankings by job ID and a post route to queue a rank refresh via RabbitMQ, powered by a ranking service.

Add a seed controller in a .NET 8 API to seed data using seed service, exposing a post endpoint that returns a seed result with job id and candidate ids.

Run and verify the docker compose setup for the .NET 8 ai resume screener, testing core api with Postgres and RabbitMQ, seeding data, and validating swagger, metrics, and rankings.

Set up the front end by integrating a free tailwind-based react admin template into the resume screener project, copying files into the react app folder and testing in Visual Studio.

Uncomment and run Docker Compose to launch React app with core API, worker, Postgres, and RabbitMQ, and tailor Tailwind admin dashboard for candidates, jobs, and rankings via open ai.

Learn to connect a React resume dashboard to a .NET core API by configuring an env file, creating a reusable API library, defining types, and implementing fetch calls.

Modify base template components in a React app to enable a flexible resume screener, adding useState and useEffect to a select and extending table cells with column and row span.

Customize the user profile by updating the header and user info cards, replacing the owner image with a png, and rebuilding the docker app to apply UI changes.

Build a jobs page that creates and lists jobs via the library API, managing loading and errors with useState and useEffect, using a component card with title and description inputs.

Build a jobs list page using a UI table, map API jobs to rows with title and created date, and display a no jobs yet message when empty.

Create the candidates page with a candidate card component to add new candidates (name, email, phone, resume text and URL) and list existing ones, with loading and error handling.

Build a candidates list component for the resume screener, featuring a table of name, email, phone, and created at, mapping API data and showing no candidates are there when empty.

Learn to load and refresh rankings on the real-world resume screener, selecting a job and generating candidate scores and justifications via a .NET API with an AI worker using OpenAI.

Display candidate rankings in a table on a component card, with name, email, score badge, and justification. Include recalculation flow and messages for no rankings yet or selecting a job.

Clean up the dashboard sidebar by trimming unused template components, removing extraneous icons and the sidebar widget, and configure nav items for jobs, candidates, and rankings with their paths.

Define and configure routing in the app by importing candidates, rankings, and jobs pages and adding routes for /jobs, /candidates, and /rankings in app.tsx.

Test and validate the updated jobs, candidates, and rankings pages by rebuilding docker services, fixing a Postgres syntax error, and validating OpenAI scoring and justification in rankings.

Build the resume screener metrics dashboard by fetching metrics via the API and rendering three metric cards for candidates, jobs, and rankings on a responsive grid.

Rename ecommerce metrics to resume screener metrics on the home page, update the dashboard, and validate the real-world resume screening flow using Docker, RabbitMQ, and an AI worker.

Demonstrate an end-to-end run with a real job and three candidates to show how the resume screener ranks, scores, and justifies candidates.