CVWIZARD

Craft Your CV, Unlock Your Career Potential

Built with the tools and technologies:

🔗 Table of Contents

• 📍 Overview
• 👾 Features
• 📁 Project Structure
  • 📂 Project Index
• 🚀 Getting Started
  • ☑️ Prerequisites
  • ⚙️ Installation
  • 🤖 Usage
• 🎗 License

---

📍 Overview

CVWizard is an innovative web application designed to enhance job application success by aligning CVs with specific job descriptions. Utilizing AI-driven analysis, it extracts and compares skills from uploaded CVs against job requirements, offering tailored advice for optimization. Ideal for job seekers aiming to boost their marketability, CVWizard simplifies the process of tailoring resumes to meet targeted job criteria effectively.

---

👾 Features

	Feature	Summary
⚙️	Architecture	Modern client-server architecture with clear separation of frontend and backend responsibilities. Backend powered by <Python> and <Flask> for API services, CV processing, and AI insights generation. Frontend built using <React>, <TypeScript>, and <TailwindCSS> for dynamic and responsive user interfaces.
🤖	AI-Powered Insights	Utilizes OpenAI (gpt-4-turbo) model via <LlamaIndex> to extract key skills, languages, and generate CV summary. Embeds CV data with OpenAI Embeddings (text-embedding-3-large) for enhanced semantic search and comparison. Automatically matches CV data against job requirements and generates AI-powered improvement suggestions.
📄	CV Processing	CV content extracted using <Docling> library for PDF text parsing and segmentation. CV data embedded with OpenAI to enable semantic search queries. Extracts key skills, languages, and experience summary from CV text.
🔩	Code Quality	Frontend developed with <TypeScript> for enhanced type safety and maintainability. Linting and formatting enforced using <ESLint> and <Prettier> with best practices for React. Backend follows modular design patterns, making code easy to extend and maintain.
🔌	Integrations	Seamlessly integrates with OpenAI API for embeddings and language model-based insights. Job data extracted via web scraping using <BeautifulSoup>. Frontend API communication handled with <Axios> for HTTP requests. Built and optimized with <Vite> for fast and lightweight frontend performance.
🧩	Modularity	Backend code organized into independent modules: <cv_reader>, <scrapper>, and <ai_insights>. Frontend components are reusable and isolated, including <AnalysisResults> and <LoadingState>. Business logic and UI layers are strictly separated for clean architecture.
🔍	Job-CV Matching	Automatically identifies matched and missing keywords between job descriptions and CVs. Provides AI-generated suggestions to improve CV alignment with job requirements. Visualizes CV-job alignment score with an interactive radial chart.
🌐	Cross-Origin Support	Backend secured with CORS policy to allow cross-origin API requests from frontend clients. Backend supports JSON-based API responses for seamless data exchange.

---

📁 Project Structure

└── CVWizard/
    ├── LICENSE
    ├── README.md
    ├── backend
    │   ├── ai_insights.py
    │   ├── app.py
    │   ├── cv_reader.py
    │   └── scrapper.py
    ├── frontend
    │   ├── .gitignore
    │   ├── README.md
    │   ├── eslint.config.js
    │   ├── index.html
    │   ├── package-lock.json
    │   ├── package.json
    │   ├── postcss.config.js
    │   ├── public
    │   │   └── wizard.png
    │   ├── src
    │   │   ├── App.tsx
    │   │   ├── components
    │   │   │   ├── AnalysisResults.tsx
    │   │   │   └── LoadingState.tsx
    │   │   ├── index.css
    │   │   ├── main.tsx
    │   │   ├── services
    │   │   │   └── api.ts
    │   │   └── vite-env.d.ts
    │   ├── tailwind.config.js
    │   ├── tsconfig.app.json
    │   ├── tsconfig.json
    │   ├── tsconfig.node.json
    │   └── vite.config.ts
    └── requirements.txt

📂 Project Index

CVWIZARD/

__root__

requirements.txt

- Manages the dependencies essential for the project's operation, ensuring compatibility and functionality across various modules - It includes libraries for web framework capabilities, cross-origin resource sharing, and specialized tools for indexing and experimental features related to llama data processing - This setup is crucial for maintaining the project's architecture and facilitating future enhancements or integrations.

backend

app.py	- Backend/app.py serves as the server-side interface for a web application, handling file uploads, data extraction, and AI-driven analysis - It processes uploaded CVs, extracts relevant information, scrapes job data from URLs, and generates insights by comparing CVs with job descriptions, facilitating a comprehensive interaction between the frontend and backend components.
scrapper.py	- Scrapes and structures job-related data from specified URLs using BeautifulSoup and requests libraries in Python - It extracts job titles, required skills, and detailed descriptions from web pages, normalizes text spacing, and handles potential errors during the scraping process, returning structured job data or error information as needed.
ai_insights.py	- Generates AI-powered insights for tailoring CVs to specific job descriptions by comparing candidate skills with job requirements - It utilizes an AI model to provide structured feedback, highlighting key areas for improvement and suggesting ways to enhance CV alignment with job skills, ultimately offering personalized advice to candidates.
cv_reader.py	- Processes and indexes curriculum vitae (CV) data by leveraging a document reader, a Markdown parser, and an OpenAI embedding model - It extracts structured information such as skills, languages, and professional summaries from the indexed data, outputting the results in a structured JSON format.

frontend

postcss.config.js	- Configures PostCSS to use TailwindCSS and Autoprefixer plugins, enhancing the CSS build process for the frontend - TailwindCSS facilitates utility-first styling, while Autoprefixer ensures CSS compatibility across different browsers - This setup is crucial for maintaining a streamlined, responsive design across the project's frontend architecture.
tsconfig.node.json	- Configures TypeScript compiler options for the frontend's node environment, focusing on modern JavaScript standards and strict type-checking to enhance code quality and maintainability - It specifically targets the setup for the Vite configuration file, ensuring efficient module resolution and error management during development without outputting compiled files.
package-lock.json	- The `package-lock.json` file located in the `frontend` directory plays a crucial role in the overall architecture of the project by ensuring consistent installations and version control of the frontend dependencies - This file lists specific versions of libraries such as React, Axios, and other UI-related packages that are essential for the frontend application's functionality - By locking down these versions, the file prevents discrepancies between development environments and ensures that all developers and deployment pipelines use the exact same versions of each package, thereby avoiding potential conflicts and bugs that could arise from version mismatches - This contributes to the stability and reliability of the frontend codebase within the larger project ecosystem.
tsconfig.json	- Manages TypeScript configuration inheritance within the frontend module by referencing specific configurations for application and node environments - It centralizes TypeScript settings, ensuring consistent compiler behavior across different parts of the frontend development environment, thereby streamlining the build process and maintenance of the codebase.
tailwind.config.js	- Configures Tailwind CSS for the frontend, specifying which HTML and JavaScript files should utilize Tailwind's utility classes - It sets up the basic theming structure and declares no additional plugins - This configuration ensures that the styling framework is optimized for the project's specific frontend architecture, enhancing UI consistency and performance.
tsconfig.app.json	- Configures TypeScript compiler options for the frontend application, targeting modern JavaScript features and optimizing for React JSX - It enhances code quality and maintainability by enforcing strict type-checking and linting rules - The configuration also improves build performance by utilizing module resolution suited for bundlers and excluding code generation.
package.json	- Serves as the configuration backbone for the frontend module of the project, specifying dependencies and scripts essential for development, building, and testing - It supports the React framework integration, ensuring tools like Vite, TypeScript, and ESLint are configured for efficient workflow and code quality management in the frontend development environment.
vite.config.ts	- Defines the configuration for the Vite build tool within the frontend architecture, specifically integrating React support through plugins - This setup enhances the development environment by enabling features like fast refresh and optimized build times, crucial for efficient frontend development and deployment in the project's broader ecosystem.
index.html	- Serves as the entry point for the CV Wizard web application, establishing the foundational HTML structure and linking essential resources - It sets up the viewport settings, specifies character encoding, and integrates the main TypeScript application file to activate the user interface components within the designated root element.
eslint.config.js	- Configures ESLint for the frontend directory, focusing on TypeScript and React standards - It integrates specific plugins for React hooks and refresh patterns, setting up recommended rules and ignoring compiled output - The configuration ensures code adheres to best practices for a modern JavaScript and TypeScript environment, enhancing maintainability and developer productivity across the project.

src

main.tsx	- Initializes the React application by setting up the root component within a strict mode context - It imports essential styles and the main application component from 'App', then mounts it to the DOM, ensuring a structured and error-checked environment for the app's frontend development.
index.css	- Integrates Tailwind CSS into the frontend architecture, enabling the application of utility-first styling across the web interface - By including base, components, and utilities directives, it ensures a consistent design system that enhances UI development speed and maintenance within the project's frontend framework - This setup is crucial for scalable and efficient style management.
App.tsx	- Frontend/src/App.tsx serves as the user interface for CVWizard, enabling users to upload their CVs, input job URLs, and utilize AI-driven analysis to tailor their CVs for specific job opportunities - It manages user interactions, data input, and displays analysis results, integrating seamlessly with backend services for data processing and insight generation.
vite-env.d.ts	- Frontend/src/vite-env.d.ts serves as a TypeScript declaration file that integrates Vite-specific types into the project's development environment - By referencing Vite's client types, it ensures that the development tools recognize and correctly handle Vite's features, enhancing the efficiency and reliability of the frontend development process within the broader codebase architecture.

components

AnalysisResults.tsx	- AnalysisResults.tsx visualizes AI-generated insights for evaluating CV-job alignment within the frontend of the application - It displays a radial chart for alignment scores, lists matched and missing keywords, and offers AI-powered suggestions to enhance CV effectiveness, contributing to a user-friendly interface that aids in optimizing job applications.
LoadingState.tsx	- Provides a visual feedback component for asynchronous operations within the application's frontend - It displays an animated spinner, a dynamic progress percentage, and a progress bar to indicate the status of ongoing processes, such as AI computations on user-uploaded CVs, enhancing user experience by communicating operation progress clearly.

services

api.ts

- Manages interactions with the backend API for a web application, facilitating the upload of CVs, retrieval of job descriptions, and generation of AI-driven insights by posting data to specific endpoints - It handles data transmission securely and manages errors effectively, ensuring robust communication between the frontend and server.

---

🚀 Getting Started

☑️ Prerequisites

Before getting started with CV Wizard, ensure your runtime environment meets the following requirements:

• Backend:

  • Python ^3.10
  • Pip for dependency management

• Frontend:

  • Node.js ^18.x
  • npm or yarn as a package manager
  • Modern browser for running the app

⚙️ Installation

Install CVWizard using one of the following methods:

Build from source:

1. Clone the CVWizard repository:

git clone https://github.com/maciekmalachowski/CVWizard

2. Navigate to the project directory:

cd CVWizard

3. Install Backend Dependencies:

cd backend
pip install -r requirements.txt

Create a .env file in the backend/ folder with the following OpenAI API key:

OPENAI_API_KEY=your_api_key_here

3. Install Frontend Dependencies:

cd frontend
npm install

🤖 Usage

Run Backend:

Navigate to the backend folder and start the Flask server:

cd backend
flask run

Backend will run on http://localhost:5000 with Flask-CORS enabled to match requests from the frontend.

Run Frontend:

Open a new terminal window and start the frontend:

cd frontend
npm run dev

Frontend will run on http://localhost:5173.

🔧 API Endpoints

Method	Endpoint	Description
POST	/read-cv	Upload and process CV
POST	/get-job-data	Scrape job description from URL
POST	/get-ai-insights	Generate AI insights comparing CV and job requirements

🎗 License

This project is protected under the MIT License.

---