CareerPilot AI is a comprehensive, AI-powered career acceleration ecosystem designed to autonomously navigate the complexities of the modern job market. By fusing Generative AI, Agentic Workflows, and Deep Semantic Search, it transforms the passive process of job hunting into a proactive, data-driven strategy.
This platform does not just "search" for jobs; it understands your career trajectory, aligns opportunities with your unique skill vector, and engineers your application materials to maximize conversion rates.
CareerPilot AI is built upon a sophisticated Multi-Agent System (MAS) architecture, where specialized AI agents collaborate to execute complex tasks:
- Function: Ingests unstructured PDF resumes and converts them into structured, semantic data.
- AI Tech: Utilizes Natural Language Processing (NLP) to identify and categorize skills, experience, and educational background with high fidelity.
- Outcome: A digital twin of your professional profile ready for deep analysis.
- Function: Simulates corporate Applicant Tracking Systems (ATS) to audit your resume.
- AI Tech: Deploys Generative AI to evaluate formatting, keyword density, and structural integrity against industry standards.
- Outcome: A granular score (0-100) and a strategic feedback report to immunize your resume against automated rejection.
- Function: Automatically segments your profile into professional domains.
- AI Tech: Deploys a Trained Machine Learning Classifier (TF-IDF + Random Forest) to predict your primary role from 25+ career categories (e.g., Data Science, DevOps, Java Development).
- Outcome: Ensures your profile is matched against the correct job market segment.
- Function: Scours internal databases and the live web for high-potential opportunities.
- AI Tech: Leverages Neural Search and Vector Embeddings to go beyond keyword matching, finding jobs that semantically align with your core competencies.
- Integration: Seamlessly connects with SerpAPI for real-time access to global job listings (Google Jobs).
- Function: Intercepts and optimizes user intent before searching.
- AI Tech: Uses Chain-of-Thought (CoT) reasoning to transform vague inputs into precise boolean search strings, ensuring high-relevance results.
- Outcome: Drastically reduces noise in job search results.
- Function: The "Brain" of the operation. It reads job descriptions like a hiring manager. Supports both auto-matched jobs and Manual Analysis (pasting your own JD).
- AI Tech: Uses Google Gemini 2.5 Flash to perform a multi-dimensional gap analysis between your profile and the target role.
- Outcome: A "Fit Score" and a detailed diagnostic report highlighting strengths, weaknesses, and critical missing skills.
- Function: Autonomously drafts hyper-personalized application assets.
- AI Tech:
- Resume Tailoring: Reconstructs your resume to emphasize the specific skills and experiences demanded by the target job.
- Cover Letter Synthesis: Composes persuasive, context-aware cover letters that weave your narrative into the company's mission.
- Function: Generates a bespoke learning and preparation strategy for a specific target role.
- AI Tech: Analyzes the gap between your current profile and the job requirements to create a step-by-step action plan.
- Outcome: A structured roadmap containing milestones, resources, and timelines to bridge skill gaps and land the job.
The system is engineered as a robust, scalable, and containerized full-stack application.
- Framework: FastAPI (Python) for high-performance, asynchronous API handling.
- Orchestration: LangGraph manages the stateful, cyclic graphs of the agentic workflows.
- Intelligence: Google Gemini 2.5 Flash (via
langchain-google-genai) provides the reasoning and generative capabilities. - Memory: PostgreSQL (via SQLAlchemy) ensures ACID-compliant persistence of user data, resumes, and job history.
- Vector Engine: ChromaDB powers the semantic retrieval system, storing embeddings of resumes and job descriptions for similarity search.
- Security: OAuth2 with JWT (JSON Web Tokens) and Argon2 password hashing.
- Framework: React.js 19 (Vite) delivers a lightning-fast, reactive user interface.
- Design System: Shadcn/UI and Tailwind CSS 4 provide a premium, accessible, and responsive aesthetic.
- Routing: React Router DOM 7 for seamless navigation.
- State Management: React Hooks manage the complex state of real-time AI interactions.
- Containerization: Docker encapsulates the entire stack, ensuring consistency across development and production environments.
- Orchestration: Docker Compose manages the multi-container lifecycle.
careerPilot/
├── backend/ # Python FastAPI Backend
│ ├── agents/ # The "Brain" - AI Agent Definitions
│ │ ├── graph.py # LangGraph workflow definition
│ │ ├── job_search_agent.py # Internal DB search logic
│ │ ├── fit_score_agent.py # Gemini-powered fit analysis
│ │ ├── roadmap_agent.py # Roadmap generation logic
│ │ └── ... (other agents)
│ ├── models/ # Data Layer
│ │ ├── database.py # DB connection & session handling
│ │ ├── schemas.py # Pydantic models for API validation
│ │ ├── user_model.py # SQLAlchemy ORM models
│ │ └── roadmap_model.py # Roadmap data models
│ ├── routers/ # API Interface
│ │ ├── careerpilot_router.py # Main endpoint for AI workflows
│ │ ├── resume_router.py # Resume management endpoints
│ │ ├── roadmap_router.py # Roadmap endpoints
│ │ └── auth_router.py # Authentication endpoints
│ ├── services/ # Business Logic & Utilities
│ │ ├── ats_service.py # ATS scoring logic
│ │ ├── embedding.py # Vector embedding service
│ │ └── pdf_reader.py # PDF extraction utility
│ ├── data/ # Local storage (Git-ignored)
│ │ ├── resumes/ # Uploaded PDF files
│ │ └── vectorstore/ # ChromaDB persistence
│ ├── main.py # Application entry point
│ ├── requirements.txt # Python dependencies
│ └── Dockerfile # Backend container definition
│
├── frontend/ # React Frontend
│ ├── src/
│ │ ├── components/ # UI Building Blocks
│ │ │ ├── layout/ # Navbar, Layout wrappers
│ │ │ ├── ui/ # Shadcn/UI components
│ │ │ └── settings/ # Configuration modals
│ │ ├── pages/ # Main Views
│ │ │ ├── CareerPilot.jsx # The AI Dashboard
│ │ │ ├── UploadResume.jsx # Resume ingestion interface
│ │ │ └── Roadmap.jsx # Roadmap visualization
│ │ ├── services/ # API Integration
│ │ │ └── api.js # Axios configuration
│ │ ├── App.jsx # Main Router
│ │ └── main.jsx # Entry point
│ ├── public/ # Static assets
│ ├── index.html # HTML template
│ ├── package.json # Node.js dependencies
│ ├── tailwind.config.js # Styling configuration
│ └── Dockerfile # Frontend container definition
│
├── docker-compose.yml # Multi-container orchestration config
├── .env # Environment variables (API Keys)
└── README.md # This documentation
- Docker Desktop (Running)
- Git (For version control)
- PostgreSQL Database: You need a running PostgreSQL instance (local or cloud).
- API Keys:
- Google Gemini API Key: Essential for all AI features. Get it here.
- SerpAPI Key: Optional, for live Google Jobs search. Get it here.
Create a .env file in the root directory with the following variables:
# Database Configuration (Required)
DATABASE_URL=postgresql://user:password@host:port/dbname
# Security (Required)
SECRET_KEY=your_super_secret_random_string
# CORS Configuration (Optional)
CORS_ORIGINS=http://localhost:5173,http://localhost:3000
# AI Keys (Can also be set via UI)
GOOGLE_API_KEY=your_gemini_key
SERPAPI_API_KEY=your_serpapi_key
TAVILY_API_KEY=your_tavily_key-
Clone the Repository
git clone https://github.com/Krishiv1611/careerPilot.git cd careerPilot -
Launch with Docker Compose
docker-compose up --build -d
-
Access the Platform
- Frontend UI: http://localhost:3000
- Backend API Docs: http://localhost:8000/docs
Backend:
- Navigate to
backend/. - Create a virtual environment:
python -m venv venv - Activate it:
source venv/bin/activate(orvenv\Scripts\activateon Windows). - Install dependencies:
pip install -r requirements.txt - Run the server:
uvicorn main:app --reload
Frontend:
- Navigate to
frontend/. - Install dependencies:
npm install - Start the dev server:
npm run dev
The backend exposes a comprehensive REST API documented via Swagger UI at /docs.
POST /auth/register: Create a new user account.POST /auth/login: Authenticate and receive a JWT access token.
POST /resume/upload: Upload a PDF resume. Triggers parsing and initial analysis.GET /resume/all: Retrieve all resumes associated with the current user.GET /resume/{id}: Get detailed data for a specific resume.POST /resume/download-pdf: Generate and download a PDF version of the improved resume.
POST /jobs/add: Manually add a job to the database.GET /jobs/all: List all available jobs.POST /jobs/reindex-all: Re-index all jobs into the vector store for semantic search.
POST /roadmap/create: Generate a personalized career roadmap for a specific job.GET /roadmap/{job_id}: Retrieve an existing roadmap for a job.
POST /careerpilot/analyze: The Core Endpoint. Triggers the multi-agent workflow:- Input: Resume ID, Job ID (optional), Search Query (optional).
- Process: Search -> Match -> Gap Analysis -> Tailoring.
- Output: Fit Score, Missing Skills, Improved Resume, Cover Letter.
POST /manual-analysis/analyze: Direct Analysis.- Input: Manual JD Text + Resume ID.
- Process: Skips search, directly analyzes the provided text against the resume.
- Open the application (or visit the Live Demo).
- Click the "Configure Keys" button in the top-right corner.
- Input your Google Gemini API Key.
- (Optional) Input your SerpAPI Key to enable live web searching.
- Save. Your keys are encrypted and stored locally in your browser.
- Go to "Upload Resume".
- Drag and drop your PDF resume.
- Watch the AI work: It will instantly parse your document, extract your skill DNA, and run an ATS audit.
- Review the ATS Score and feedback.
- Navigate to "CareerPilot AI" (Dashboard).
- Select your uploaded resume from the dropdown.
- Auto-Match: Leave the search bar empty and click "Find Jobs". The AI will infer your ideal roles based on your extracted skills.
- Targeted Search: Enter a specific role (e.g., "Senior React Developer") to narrow the scope.
- Browse the intelligent job cards.
- Click "Analyze Match" on a role that interests you.
- The Fit Analysis Agent will perform a deep dive:
- Fit Score: A percentage indicating your alignment.
- Gap Analysis: Identifies critical missing skills.
- Tailored Resume: Generates a new version of your resume optimized for this specific job.
- Cover Letter: Drafts a compelling narrative for your application.
- Roadmap: View a step-by-step plan to acquire the missing skills.
- Use these AI-generated assets to apply with confidence.
- Have a specific job description from another site?
- Go to the "Analyze Match" section.
- Paste the Job Description text directly.
- The AI will run the full suite of analysis (Fit Score, Resume Tailoring) on your pasted text.
- "Connection Refused": Ensure the backend container is running. Check logs with
docker logs careerpilot-backend. - "Database Error": Ensure your
DATABASE_URLis correct and the PostgreSQL server is running. - "Google API Key Missing": The AI agents cannot function without fuel. Configure your key in the settings modal.
- "Search Query Missing": This has been resolved in the latest patch by optimizing the graph execution order.
Contributions are welcome! Please follow these steps:
- Fork the repository.
- Create a new branch (
git checkout -b feature/AmazingFeature). - Commit your changes (
git commit -m 'Add some AmazingFeature'). - Push to the branch (
git push origin feature/AmazingFeature). - Open a Pull Request.
Distributed under the MIT License. See LICENSE for more information.
Powered by Advanced Agentic AI. Engineered for Career Success.